feat: add formdata endpoints for documents,envelopes,templates

Adds the missing endpoints for documents, envelopes and
templates supporting file uploads in a singular request.

Also updates frontend components that would use the prior
hidden endpoints.

apps/remix/app/components/dialogs/template-create-dialog.tsx

@@ -7,9 +7,9 @@ import { FilePlus, Loader } from 'lucide-react';
 import { useNavigate } from 'react-router';
 
 import { useSession } from '@documenso/lib/client-only/providers/session';
-import { putPdfFile } from '@documenso/lib/universal/upload/put-file';
 import { formatTemplatesPath } from '@documenso/lib/utils/teams';
 import { trpc } from '@documenso/trpc/react';
+import type { TCreateTemplatePayloadSchema } from '@documenso/trpc/server/template-router/schema';
 import { Button } from '@documenso/ui/primitives/button';
 import {
   Dialog,
@@ -54,13 +54,17 @@ export const TemplateCreateDialog = ({ folderId }: TemplateCreateDialogProps) =>
     setIsUploadingFile(true);
 
     try {
-      const response = await putPdfFile(file);
-
-      const { legacyTemplateId: id } = await createTemplate({
+      const payload = {
         title: file.name,
-        templateDocumentDataId: response.id,
         folderId: folderId,
-      });
+      } satisfies TCreateTemplatePayloadSchema;
+
+      const formData = new FormData();
+
+      formData.append('payload', JSON.stringify(payload));
+      formData.append('file', file);
+
+      const { envelopeId: id } = await createTemplate(formData);
 
       toast({
         title: _(msg`Template document uploaded`),

apps/remix/app/components/general/document/document-drop-zone-wrapper.tsx

@@ -16,9 +16,9 @@ import { APP_DOCUMENT_UPLOAD_SIZE_LIMIT, IS_BILLING_ENABLED } from '@documenso/l
 import { DEFAULT_DOCUMENT_TIME_ZONE, TIME_ZONES } from '@documenso/lib/constants/time-zones';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { megabytesToBytes } from '@documenso/lib/universal/unit-convertions';
-import { putPdfFile } from '@documenso/lib/universal/upload/put-file';
 import { formatDocumentsPath } from '@documenso/lib/utils/teams';
 import { trpc } from '@documenso/trpc/react';
+import type { TCreateDocumentPayloadSchema } from '@documenso/trpc/server/document-router/create-document.types';
 import { cn } from '@documenso/ui/lib/utils';
 import { useToast } from '@documenso/ui/primitives/use-toast';
 
@@ -62,14 +62,18 @@ export const DocumentDropZoneWrapper = ({ children, className }: DocumentDropZon
     try {
       setIsLoading(true);
 
-      const response = await putPdfFile(file);
-
-      const { legacyDocumentId: id } = await createDocument({
+      const payload = {
         title: file.name,
-        documentDataId: response.id,
-        timezone: userTimezone, // Note: When migrating to v2 document upload remember to pass this through as a 'userTimezone' field.
+        timezone: userTimezone,
         folderId: folderId ?? undefined,
-      });
+      } satisfies TCreateDocumentPayloadSchema;
+
+      const formData = new FormData();
+
+      formData.append('payload', JSON.stringify(payload));
+      formData.append('file', file);
+
+      const { envelopeId: id } = await createDocument(formData);
 
       void refreshLimits();
 

apps/remix/app/components/general/document/document-upload-button.tsx

@@ -13,9 +13,9 @@ import { useSession } from '@documenso/lib/client-only/providers/session';
 import { APP_DOCUMENT_UPLOAD_SIZE_LIMIT } from '@documenso/lib/constants/app';
 import { DEFAULT_DOCUMENT_TIME_ZONE, TIME_ZONES } from '@documenso/lib/constants/time-zones';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import { putPdfFile } from '@documenso/lib/universal/upload/put-file';
 import { formatDocumentsPath } from '@documenso/lib/utils/teams';
 import { trpc } from '@documenso/trpc/react';
+import type { TCreateDocumentPayloadSchema } from '@documenso/trpc/server/document-router/create-document.types';
 import { cn } from '@documenso/ui/lib/utils';
 import { DocumentDropzone } from '@documenso/ui/primitives/document-upload';
 import {
@@ -73,14 +73,18 @@ export const DocumentUploadButton = ({ className }: DocumentUploadButtonProps) =
     try {
       setIsLoading(true);
 
-      const response = await putPdfFile(file);
-
-      const { legacyDocumentId: id } = await createDocument({
+      const payload = {
         title: file.name,
-        documentDataId: response.id,
         timezone: userTimezone,
         folderId: folderId ?? undefined,
-      });
+      } satisfies TCreateDocumentPayloadSchema;
+
+      const formData = new FormData();
+
+      formData.append('payload', JSON.stringify(payload));
+      formData.append('file', file);
+
+      const { envelopeId: id } = await createDocument(formData);
 
       void refreshLimits();
 

apps/remix/app/components/general/document/envelope-upload-button.tsx

@@ -14,9 +14,9 @@ import { useSession } from '@documenso/lib/client-only/providers/session';
 import { APP_DOCUMENT_UPLOAD_SIZE_LIMIT } from '@documenso/lib/constants/app';
 import { TIME_ZONES } from '@documenso/lib/constants/time-zones';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import { putPdfFile } from '@documenso/lib/universal/upload/put-file';
 import { formatDocumentsPath, formatTemplatesPath } from '@documenso/lib/utils/teams';
 import { trpc } from '@documenso/trpc/react';
+import type { TCreateEnvelopePayload } from '@documenso/trpc/server/envelope-router/create-envelope.types';
 import { cn } from '@documenso/ui/lib/utils';
 import { DocumentDropzone } from '@documenso/ui/primitives/document-upload';
 import {
@@ -78,35 +78,24 @@ export const EnvelopeUploadButton = ({ className, type, folderId }: EnvelopeUplo
     try {
       setIsLoading(true);
 
-      const result = await Promise.all(
-        files.map(async (file) => {
-          try {
-            const response = await putPdfFile(file);
-
-            return {
-              title: file.name,
-              documentDataId: response.id,
-            };
-          } catch (err) {
-            console.error(err);
-            throw new Error('Failed to upload document');
-          }
-        }),
-      );
-
-      const envelopeItemsToCreate = result.filter(
-        (item): item is { title: string; documentDataId: string } => item !== undefined,
-      );
-
-      const { id } = await createEnvelope({
+      const payload = {
         folderId,
         type,
         title: files[0].name,
-        items: envelopeItemsToCreate,
         meta: {
           timezone: userTimezone,
         },
-      }).catch((error) => {
+      } satisfies TCreateEnvelopePayload;
+
+      const formData = new FormData();
+
+      formData.append('payload', JSON.stringify(payload));
+
+      for (const file of files) {
+        formData.append('files', file);
+      }
+
+      const { id } = await createEnvelope(formData).catch((error) => {
         console.error(error);
 
         throw error;

apps/remix/app/components/general/envelope-editor/envelope-editor-settings-dialog.tsx

@@ -242,7 +242,6 @@ export const EnvelopeEditorSettingsDialog = ({
     try {
       await updateEnvelope({
         envelopeId: envelope.id,
-        envelopeType: envelope.type,
         data: {
           externalId: data.externalId || null,
           visibility: data.visibility,

apps/remix/app/components/general/envelope-editor/envelope-editor-upload-page.tsx

@@ -142,7 +142,7 @@ export const EnvelopeEditorUploadPage = () => {
 
     const { createdEnvelopeItems } = await createEnvelopeItems({
       envelopeId: envelope.id,
-      items: envelopeItemsToCreate,
+      data: envelopeItemsToCreate,
     }).catch((error) => {
       console.error(error);
 

apps/remix/app/components/general/template/template-drop-zone-wrapper.tsx

@@ -10,9 +10,9 @@ import { match } from 'ts-pattern';
 
 import { APP_DOCUMENT_UPLOAD_SIZE_LIMIT } from '@documenso/lib/constants/app';
 import { megabytesToBytes } from '@documenso/lib/universal/unit-convertions';
-import { putPdfFile } from '@documenso/lib/universal/upload/put-file';
 import { formatTemplatesPath } from '@documenso/lib/utils/teams';
 import { trpc } from '@documenso/trpc/react';
+import type { TCreateTemplatePayloadSchema } from '@documenso/trpc/server/template-router/schema';
 import { cn } from '@documenso/ui/lib/utils';
 import { useToast } from '@documenso/ui/primitives/use-toast';
 
@@ -40,13 +40,17 @@ export const TemplateDropZoneWrapper = ({ children, className }: TemplateDropZon
     try {
       setIsLoading(true);
 
-      const documentData = await putPdfFile(file);
-
-      const { legacyTemplateId: id } = await createTemplate({
+      const payload = {
         title: file.name,
-        templateDocumentDataId: documentData.id,
         folderId: folderId ?? undefined,
-      });
+      } satisfies TCreateTemplatePayloadSchema;
+
+      const formData = new FormData();
+
+      formData.append('payload', JSON.stringify(payload));
+      formData.append('file', file);
+
+      const { envelopeId: id } = await createTemplate(formData);
 
       toast({
         title: _(msg`Template uploaded`),

apps/remix/server/trpc/hono-trpc-open-api.ts

@@ -1,10 +1,10 @@
 import type { Context } from 'hono';
-import { createOpenApiFetchHandler } from 'trpc-to-openapi';
 
 import { API_V2_BETA_URL } from '@documenso/lib/constants/app';
 import { AppError, genericErrorCodeToTrpcErrorCodeMap } from '@documenso/lib/errors/app-error';
 import { createTrpcContext } from '@documenso/trpc/server/context';
 import { appRouter } from '@documenso/trpc/server/router';
+import { createOpenApiFetchHandler } from '@documenso/trpc/utils/openapi-fetch-handler';
 import { handleTrpcRouterError } from '@documenso/trpc/utils/trpc-error-handler';
 
 export const openApiTrpcServerHandler = async (c: Context) => {

package.json

@@ -44,7 +44,7 @@
     "@commitlint/cli": "^17.7.1",
     "@commitlint/config-conventional": "^17.7.0",
     "@lingui/cli": "^5.2.0",
-    "@prisma/client": "^6.8.2",
+    "@prisma/client": "^6.18.0",
     "dotenv": "^16.5.0",
     "dotenv-cli": "^8.0.0",
     "eslint": "^8.40.0",
@@ -54,11 +54,21 @@
     "nodemailer": "^6.10.1",
     "playwright": "1.52.0",
     "prettier": "^3.3.3",
-    "prisma": "^6.8.2",
+    "prisma": "^6.18.0",
     "prisma-extension-kysely": "^3.0.0",
     "prisma-kysely": "^1.8.0",
     "rimraf": "^5.0.1",
     "turbo": "^1.9.3",
+    "@trpc/client": "11.7.0",
+    "@trpc/react-query": "11.7.0",
+    "@trpc/server": "11.7.0",
+    "superjson": "^2.2.5",
+    "trpc-to-openapi": "2.4.0",
+    "zod-openapi": "^4.2.4",
+    "@ts-rest/core": "^3.52.1",
+    "@ts-rest/open-api": "^3.52.1",
+    "@ts-rest/serverless": "^3.52.1",
+    "zod-prisma-types": "3.3.5",
     "vite": "^6.3.5"
   },
   "name": "@documenso/root",
@@ -76,12 +86,12 @@
     "mupdf": "^1.0.0",
     "react": "^18",
     "typescript": "5.6.2",
-    "zod": "3.24.1"
+    "zod": "^3.25.76"
   },
   "overrides": {
-    "zod": "3.24.1"
+    "zod": "^3.25.76"
   },
   "trigger.dev": {
     "endpointId": "documenso-app"
   }
-}
+}

packages/api/package.json

@@ -17,14 +17,14 @@
   "dependencies": {
     "@documenso/lib": "*",
     "@documenso/prisma": "*",
-    "@ts-rest/core": "^3.30.5",
-    "@ts-rest/open-api": "^3.33.0",
-    "@ts-rest/serverless": "^3.30.5",
+    "@ts-rest/core": "^3.52.0",
+    "@ts-rest/open-api": "^3.52.0",
+    "@ts-rest/serverless": "^3.52.0",
     "@types/swagger-ui-react": "^5.18.0",
     "luxon": "^3.4.0",
-    "superjson": "^1.13.1",
+    "superjson": "^2.2.5",
     "swagger-ui-react": "^5.21.0",
     "ts-pattern": "^5.0.5",
-    "zod": "3.24.1"
+    "zod": "^3.25.76"
   }
 }

packages/api/v1/implementation.ts

@@ -20,12 +20,12 @@ import {
   getEnvelopeWhereInput,
 } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
 import { deleteDocumentField } from '@documenso/lib/server-only/field/delete-document-field';
-import { updateDocumentFields } from '@documenso/lib/server-only/field/update-document-fields';
+import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
 import { insertFormValuesInPdf } from '@documenso/lib/server-only/pdf/insert-form-values-in-pdf';
-import { deleteDocumentRecipient } from '@documenso/lib/server-only/recipient/delete-document-recipient';
+import { deleteEnvelopeRecipient } from '@documenso/lib/server-only/recipient/delete-envelope-recipient';
 import { getRecipientsForDocument } from '@documenso/lib/server-only/recipient/get-recipients-for-document';
 import { setDocumentRecipients } from '@documenso/lib/server-only/recipient/set-document-recipients';
-import { updateDocumentRecipients } from '@documenso/lib/server-only/recipient/update-document-recipients';
+import { updateEnvelopeRecipients } from '@documenso/lib/server-only/recipient/update-envelope-recipients';
 import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
 import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
 import { findTemplates } from '@documenso/lib/server-only/template/find-templates';
@@ -1285,7 +1285,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    const updatedRecipient = await updateDocumentRecipients({
+    const updatedRecipient = await updateEnvelopeRecipients({
       userId: user.id,
       teamId: team.id,
       id: {
@@ -1336,7 +1336,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       },
     });
 
-    const deletedRecipient = await deleteDocumentRecipient({
+    const deletedRecipient = await deleteEnvelopeRecipient({
       userId: user.id,
       teamId: team.id,
       recipientId: Number(recipientId),
@@ -1634,10 +1634,13 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    const { fields } = await updateDocumentFields({
+    const { fields } = await updateEnvelopeFields({
       userId: user.id,
       teamId: team.id,
-      documentId: legacyDocumentId,
+      id: {
+        type: 'documentId',
+        id: legacyDocumentId,
+      },
       fields: [
         {
           id: Number(fieldId),

packages/app-tests/constants/field-alignment-pdf.ts

@@ -0,0 +1,498 @@
+import { FieldType } from '@prisma/client';
+
+import type { TFieldAndMeta } from '@documenso/lib/types/field-meta';
+import { toCheckboxCustomText } from '@documenso/lib/utils/fields';
+
+export type FieldTestData = TFieldAndMeta & {
+  page: number;
+  positionX: number;
+  positionY: number;
+  width: number;
+  height: number;
+  customText: string;
+  signature?: string;
+};
+
+const columnWidth = 19.125;
+const rowHeight = 6.7;
+
+const alignmentGridStartX = 31;
+const alignmentGridStartY = 19.02;
+
+export const ALIGNMENT_TEST_FIELDS: FieldTestData[] = [
+  /**
+   * Row 1 EMAIL
+   */
+  {
+    type: FieldType.EMAIL,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'email',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'admin@documenso.com',
+  },
+  {
+    type: FieldType.EMAIL,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'email',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'admin@documenso.com',
+  },
+  {
+    type: FieldType.EMAIL,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'email',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'admin@documenso.com',
+  },
+  /**
+   * Row 2 NAME
+   */
+  {
+    type: FieldType.NAME,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'name',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'John Doe',
+  },
+  {
+    type: FieldType.NAME,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'name',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'John Doe',
+  },
+  {
+    type: FieldType.NAME,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'name',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'John Doe',
+  },
+  /**
+   * Row 3 DATE
+   */
+  {
+    type: FieldType.DATE,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'date',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.DATE,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'date',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.DATE,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'date',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  /**
+   * Row 4 TEXT
+   */
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'text',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'text',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'text',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  /**
+   * Row 5 NUMBER
+   */
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'number',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'number',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'number',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '123456789',
+  },
+  /**
+   * Row 6 Initials
+   */
+  {
+    type: FieldType.INITIALS,
+    fieldMeta: {
+      fontSize: 10,
+      textAlign: 'left',
+      type: 'initials',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'JD',
+  },
+  {
+    type: FieldType.INITIALS,
+    fieldMeta: {
+      textAlign: 'center',
+      type: 'initials',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'JD',
+  },
+  {
+    type: FieldType.INITIALS,
+    fieldMeta: {
+      fontSize: 20,
+      textAlign: 'right',
+      type: 'initials',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'JD',
+  },
+  /**
+   * Row 7 Radio
+   */
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      fontSize: 10,
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '0',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '2',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      fontSize: 20,
+      direction: 'horizontal',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+  },
+  /**
+   * Row 8 Checkbox
+   */
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      fontSize: 10,
+      direction: 'vertical',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: toCheckboxCustomText([0]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: toCheckboxCustomText([1]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      fontSize: 20,
+      direction: 'horizontal',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+  },
+  /**
+   * Row 8 Dropdown
+   */
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      fontSize: 10,
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      fontSize: 20,
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }, { value: 'Option 3' }],
+      type: 'dropdown',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: 'Option 1',
+  },
+  /**
+   * Row 9 Signature
+   */
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      fontSize: 10,
+      type: 'signature',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      fontSize: 20,
+      type: 'signature',
+    },
+    page: 1,
+    height: rowHeight,
+    width: columnWidth,
+    positionX: 0,
+    positionY: 0,
+    customText: '',
+    signature: 'My Signature',
+  },
+] as const;
+
+export const formatAlignmentTestFields = ALIGNMENT_TEST_FIELDS.map((field, index) => {
+  const row = Math.floor(index / 3);
+  const column = index % 3;
+
+  return {
+    ...field,
+    positionX: alignmentGridStartX + column * columnWidth,
+    positionY: alignmentGridStartY + row * rowHeight,
+  };
+});

packages/app-tests/constants/field-meta-pdf.ts

@@ -0,0 +1,482 @@
+import { FieldType } from '@prisma/client';
+
+import { toCheckboxCustomText } from '@documenso/lib/utils/fields';
+import {
+  CheckboxValidationRules,
+  numberFormatValues,
+} from '@documenso/ui/primitives/document-flow/field-items-advanced-settings/constants';
+
+import type { FieldTestData } from './field-alignment-pdf';
+
+const columnWidth = 20.1;
+const fullColumnWidth = 75.8;
+const rowHeight = 9.8;
+const rowPadding = 1.8;
+
+const alignmentGridStartX = 11.85;
+const alignmentGridStartY = 15.07;
+
+const calculatePosition = (row: number, column: number, width: 'full' | 'column' = 'column') => {
+  return {
+    height: rowHeight,
+    width: width === 'full' ? fullColumnWidth : columnWidth,
+    positionX: alignmentGridStartX + (column ?? 0) * columnWidth,
+    positionY: alignmentGridStartY + row * (rowHeight + rowPadding),
+  };
+};
+
+export const FIELD_META_TEST_FIELDS: FieldTestData[] = [
+  /**
+   * PAGE 2 Signature
+   */
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(0, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(1, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(2, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+  {
+    type: FieldType.SIGNATURE,
+    fieldMeta: {
+      type: 'signature',
+    },
+    page: 2,
+    ...calculatePosition(3, 0),
+    customText: '',
+    signature: 'My Signature',
+  },
+
+  /**
+   * PAGE 3 TEXT
+   */
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+    },
+    page: 3,
+    ...calculatePosition(0, 0, 'full'),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+    },
+    page: 3,
+    ...calculatePosition(1, 0),
+    customText: '123456789123456789123456789123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      characterLimit: 5,
+    },
+    page: 3,
+    ...calculatePosition(2, 0),
+    customText: '12345',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      placeholder: 'Demo Placeholder',
+    },
+    page: 3,
+    ...calculatePosition(3, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      label: 'Demo Label',
+    },
+    page: 3,
+    ...calculatePosition(3, 1),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      text: 'Prefilled text',
+    },
+    page: 3,
+    ...calculatePosition(3, 2),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      required: true,
+    },
+    page: 3,
+    ...calculatePosition(4, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.TEXT,
+    fieldMeta: {
+      type: 'text',
+      readOnly: true,
+      text: 'Readonly Value',
+    },
+    page: 3,
+    ...calculatePosition(4, 1),
+    customText: 'Readonly Value',
+  },
+
+  /**
+   * PAGE 4 NUMBER
+   */
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+    },
+    page: 4,
+    ...calculatePosition(0, 0, 'full'),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+    },
+    page: 4,
+    ...calculatePosition(1, 0),
+    customText: '123456789123456789123456789123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      minValue: 0,
+      maxValue: 100,
+    },
+    page: 4,
+    ...calculatePosition(2, 0),
+    customText: '50',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      numberFormat: numberFormatValues[0].value, // Todo: Envelopes - Check this.
+      value: '123,456,789.00',
+    },
+    page: 4,
+    ...calculatePosition(2, 1),
+    customText: '123,456,789.00',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      placeholder: 'Demo Placeholder',
+    },
+    page: 4,
+    ...calculatePosition(3, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      label: 'Demo Label',
+    },
+    page: 4,
+    ...calculatePosition(3, 1),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      value: '123',
+    },
+    page: 4,
+    ...calculatePosition(3, 2),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      required: true,
+    },
+    page: 4,
+    ...calculatePosition(4, 0),
+    customText: '123456789',
+  },
+  {
+    type: FieldType.NUMBER,
+    fieldMeta: {
+      type: 'number',
+      readOnly: true,
+    },
+    page: 4,
+    ...calculatePosition(4, 1),
+    customText: '123456789',
+  },
+
+  /**
+   * PAGE 5 RADIO
+   */
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'horizontal',
+      type: 'radio',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(0, 0, 'full'),
+    customText: '0',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(1, 0),
+    customText: '2',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(2, 0),
+    customText: '',
+  },
+  {
+    type: FieldType.RADIO,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'radio',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 5,
+    ...calculatePosition(2, 1),
+    customText: '',
+  },
+
+  /**
+   * PAGE 6 CHECKBOX
+   */
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'horizontal',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: true, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 2, checked: false, value: 'Option 3' },
+        { id: 2, checked: false, value: 'Option 4' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(0, 0, 'full'),
+    customText: toCheckboxCustomText([0]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: true, value: 'Option 2' },
+        { id: 2, checked: true, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(1, 0),
+    customText: toCheckboxCustomText([1]),
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      required: true,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(2, 0),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      readOnly: true,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(2, 1),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      validationRule: CheckboxValidationRules.SELECT_AT_LEAST,
+      validationLength: 2,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(3, 0),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      validationRule: CheckboxValidationRules.SELECT_EXACTLY,
+      validationLength: 2,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(3, 1),
+    customText: '',
+  },
+  {
+    type: FieldType.CHECKBOX,
+    fieldMeta: {
+      direction: 'vertical',
+      type: 'checkbox',
+      validationRule: CheckboxValidationRules.SELECT_AT_MOST,
+      validationLength: 2,
+      values: [
+        { id: 1, checked: false, value: 'Option 1' },
+        { id: 2, checked: false, value: 'Option 2' },
+        { id: 3, checked: false, value: 'Option 3' },
+      ],
+    },
+    page: 6,
+    ...calculatePosition(3, 2),
+    customText: '',
+  },
+
+  /**
+   * PAGE 7 DROPDOWN
+   */
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+    },
+    page: 7,
+    ...calculatePosition(0, 0, 'full'),
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }],
+      type: 'dropdown',
+      defaultValue: 'Option 1',
+    },
+    page: 7,
+    ...calculatePosition(1, 0),
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }, { value: 'Option 3' }],
+      type: 'dropdown',
+      required: true,
+    },
+    page: 7,
+    ...calculatePosition(2, 0),
+    customText: 'Option 1',
+  },
+  {
+    type: FieldType.DROPDOWN,
+    fieldMeta: {
+      values: [{ value: 'Option 1' }, { value: 'Option 2' }, { value: 'Option 3' }],
+      type: 'dropdown',
+      readOnly: true,
+    },
+    page: 7,
+    ...calculatePosition(2, 1),
+    customText: 'Option 1',
+  },
+] as const;
+
+export const formatFieldMetaTestFields = FIELD_META_TEST_FIELDS.map((field, index) => {
+  return {
+    ...field,
+  };
+});

packages/app-tests/e2e/api/v2/envelopes-api.spec.ts

@@ -0,0 +1,264 @@
+import { expect, test } from '@playwright/test';
+import type { Team, User } from '@prisma/client';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+import { incrementDocumentId } from '@documenso/lib/server-only/envelope/increment-id';
+import { createApiToken } from '@documenso/lib/server-only/public-api/create-api-token';
+import { prefixedId } from '@documenso/lib/universal/id';
+import { prisma } from '@documenso/prisma';
+import {
+  DocumentSource,
+  DocumentVisibility,
+  EnvelopeType,
+  RecipientRole,
+} from '@documenso/prisma/client';
+import { seedUser } from '@documenso/prisma/seed/users';
+import type { TCreateEnvelopeItemsRequest } from '@documenso/trpc/server/envelope-router/create-envelope-items.types';
+import type { TCreateEnvelopeRecipientsRequest } from '@documenso/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.types';
+import type { TGetEnvelopeResponse } from '@documenso/trpc/server/envelope-router/get-envelope.types';
+import type { TUpdateEnvelopeRequest } from '@documenso/trpc/server/envelope-router/update-envelope.types';
+
+import { formatAlignmentTestFields } from '../../../constants/field-alignment-pdf';
+import { FIELD_META_TEST_FIELDS } from '../../../constants/field-meta-pdf';
+
+const WEBAPP_BASE_URL = NEXT_PUBLIC_WEBAPP_URL();
+const baseUrl = `${WEBAPP_BASE_URL}/api/v2-beta`;
+
+test.describe.configure({
+  mode: 'parallel',
+});
+
+test.describe('API V2 Envelopes', () => {
+  let userA: User, teamA: Team, userB: User, teamB: Team, tokenA: string, tokenB: string;
+
+  test.beforeEach(async () => {
+    ({ user: userA, team: teamA } = await seedUser());
+    ({ token: tokenA } = await createApiToken({
+      userId: userA.id,
+      teamId: teamA.id,
+      tokenName: 'userA',
+      expiresIn: null,
+    }));
+
+    ({ user: userB, team: teamB } = await seedUser());
+    ({ token: tokenB } = await createApiToken({
+      userId: userB.id,
+      teamId: teamB.id,
+      tokenName: 'userB',
+      expiresIn: null,
+    }));
+  });
+
+  /**
+   * Creates envelopes with the two field test PDFs.
+   */
+  test('Envelope full test', async ({ request }) => {
+    // Step 1: Create initial envelope with Prisma (with first envelope item)
+    const alignmentPdf = fs
+      .readFileSync(path.join(__dirname, '../../../../../assets/field-font-alignment.pdf'))
+      .toString('base64');
+
+    const fieldMetaPdf = fs
+      .readFileSync(path.join(__dirname, '../../../../../assets/field-meta.pdf'))
+      .toString('base64');
+
+    const alignmentDocumentData = await prisma.documentData.create({
+      data: {
+        type: 'BYTES_64',
+        data: alignmentPdf,
+        initialData: alignmentPdf,
+      },
+    });
+
+    const documentId = await incrementDocumentId();
+    const documentMeta = await prisma.documentMeta.create({
+      data: {},
+    });
+
+    const createdEnvelope = await prisma.envelope.create({
+      data: {
+        id: prefixedId('envelope'),
+        secondaryId: documentId.formattedDocumentId,
+        internalVersion: 2,
+        type: EnvelopeType.DOCUMENT,
+        documentMetaId: documentMeta.id,
+        source: DocumentSource.DOCUMENT,
+        title: `Envelope Full Field Test`,
+        status: 'DRAFT',
+        userId: userA.id,
+        teamId: teamA.id,
+        envelopeItems: {
+          create: {
+            id: prefixedId('envelope_item'),
+            title: `Alignment Test`,
+            documentDataId: alignmentDocumentData.id,
+            order: 1,
+          },
+        },
+      },
+      include: {
+        envelopeItems: true,
+      },
+    });
+
+    // Step 2: Create second envelope item via API
+    const fieldMetaDocumentData = await prisma.documentData.create({
+      data: {
+        type: 'BYTES_64',
+        data: fieldMetaPdf,
+        initialData: fieldMetaPdf,
+      },
+    });
+
+    const createEnvelopeItemsRequest: TCreateEnvelopeItemsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: [
+        {
+          title: 'Field Meta Test',
+          documentDataId: fieldMetaDocumentData.id,
+        },
+      ],
+    };
+
+    const createItemsRes = await request.post(`${baseUrl}/envelope/item/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: createEnvelopeItemsRequest,
+    });
+
+    expect(createItemsRes.ok()).toBeTruthy();
+    expect(createItemsRes.status()).toBe(200);
+
+    // Step 3: Update envelope via API
+    const updateEnvelopeRequest: TUpdateEnvelopeRequest = {
+      envelopeId: createdEnvelope.id,
+      envelopeType: EnvelopeType.DOCUMENT,
+      data: {
+        title: 'Envelope Full Field Test',
+        visibility: DocumentVisibility.MANAGER_AND_ABOVE,
+      },
+    };
+
+    const updateRes = await request.post(`${baseUrl}/envelope/update`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: updateEnvelopeRequest,
+    });
+
+    expect(updateRes.ok()).toBeTruthy();
+    expect(updateRes.status()).toBe(200);
+
+    // Step 4: Create recipient via API
+    const createRecipientsRequest: TCreateEnvelopeRecipientsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: [
+        {
+          email: userA.email,
+          name: userA.name || '',
+          role: RecipientRole.SIGNER,
+          accessAuth: [],
+          actionAuth: [],
+        },
+      ],
+    };
+
+    const createRecipientsRes = await request.post(`${baseUrl}/envelope/recipient/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: createRecipientsRequest,
+    });
+
+    expect(createRecipientsRes.ok()).toBeTruthy();
+    expect(createRecipientsRes.status()).toBe(200);
+
+    // Step 5: Get envelope to retrieve recipients and envelope items
+    const getRes = await request.get(`${baseUrl}/envelope/${createdEnvelope.id}`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+    });
+
+    expect(getRes.ok()).toBeTruthy();
+    expect(getRes.status()).toBe(200);
+
+    const envelopeResponse = (await getRes.json()) as TGetEnvelopeResponse;
+
+    const recipientId = envelopeResponse.recipients[0].id;
+    const alignmentItem = envelopeResponse.envelopeItems.find(
+      (item: { order: number }) => item.order === 1,
+    );
+    const fieldMetaItem = envelopeResponse.envelopeItems.find(
+      (item: { order: number }) => item.order === 2,
+    );
+
+    expect(recipientId).toBeDefined();
+    expect(alignmentItem).toBeDefined();
+    expect(fieldMetaItem).toBeDefined();
+
+    if (!alignmentItem || !fieldMetaItem) {
+      throw new Error('Envelope items not found');
+    }
+
+    // Step 6: Create fields for first PDF (alignment fields)
+    const alignmentFieldsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: formatAlignmentTestFields.map((field) => ({
+        recipientId,
+        envelopeItemId: alignmentItem.id,
+        type: field.type,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
+        width: field.width,
+        height: field.height,
+        fieldMeta: field.fieldMeta,
+      })),
+    };
+
+    const createAlignmentFieldsRes = await request.post(`${baseUrl}/envelope/field/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: alignmentFieldsRequest,
+    });
+
+    expect(createAlignmentFieldsRes.ok()).toBeTruthy();
+    expect(createAlignmentFieldsRes.status()).toBe(200);
+
+    // Step 7: Create fields for second PDF (field-meta fields)
+    const fieldMetaFieldsRequest = {
+      envelopeId: createdEnvelope.id,
+      data: FIELD_META_TEST_FIELDS.map((field) => ({
+        recipientId,
+        envelopeItemId: fieldMetaItem.id,
+        type: field.type,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
+        width: field.width,
+        height: field.height,
+        fieldMeta: field.fieldMeta,
+      })),
+    };
+
+    const createFieldMetaFieldsRes = await request.post(`${baseUrl}/envelope/field/create-many`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+      data: fieldMetaFieldsRequest,
+    });
+
+    expect(createFieldMetaFieldsRes.ok()).toBeTruthy();
+    expect(createFieldMetaFieldsRes.status()).toBe(200);
+
+    // Step 8: Verify final envelope structure
+    const finalGetRes = await request.get(`${baseUrl}/envelope/${createdEnvelope.id}`, {
+      headers: { Authorization: `Bearer ${tokenA}` },
+    });
+
+    expect(finalGetRes.ok()).toBeTruthy();
+    const finalEnvelope = (await finalGetRes.json()) as TGetEnvelopeResponse;
+
+    // Verify structure
+    expect(finalEnvelope.envelopeItems.length).toBe(2);
+    expect(finalEnvelope.recipients.length).toBe(1);
+    expect(finalEnvelope.fields.length).toBe(
+      formatAlignmentTestFields.length + FIELD_META_TEST_FIELDS.length,
+    );
+    expect(finalEnvelope.title).toBe('Envelope Full Field Test');
+    expect(finalEnvelope.type).toBe(EnvelopeType.DOCUMENT);
+  });
+});

packages/app-tests/e2e/envelopes/envelope-alignment.spec.ts

@@ -0,0 +1,282 @@
+// sort-imports-ignore
+
+// ---- PATCH pdfjs-dist's canvas require BEFORE importing it ----
+import Module from 'module';
+import { Canvas, Image } from 'skia-canvas';
+
+// Intercept require('canvas') and return skia-canvas equivalents
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (path: string) {
+  if (path === 'canvas') {
+    return {
+      createCanvas: (width: number, height: number) => new Canvas(width, height),
+      Image, // needed by pdfjs-dist
+    };
+  }
+  // eslint-disable-next-line prefer-rest-params, @typescript-eslint/consistent-type-assertions
+  return originalRequire.apply(this, arguments as unknown as [string]);
+};
+
+import pixelMatch from 'pixelmatch';
+import { PNG } from 'pngjs';
+import type { TestInfo } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+import { DocumentStatus } from '@prisma/client';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf.js';
+
+import { getFile } from '@documenso/lib/universal/upload/get-file';
+import { prisma } from '@documenso/prisma';
+import { seedAlignmentTestDocument } from '@documenso/prisma/seed/initial-seed';
+import { seedUser } from '@documenso/prisma/seed/users';
+
+import { apiSignin } from '../fixtures/authentication';
+
+test.describe.configure({ mode: 'parallel', timeout: 60000 });
+
+test('field placement visual regression', async ({ page }, testInfo) => {
+  const { user, team } = await seedUser();
+
+  const envelope = await seedAlignmentTestDocument({
+    userId: user.id,
+    teamId: team.id,
+    recipientName: user.name || '',
+    recipientEmail: user.email,
+    insertFields: true,
+    status: DocumentStatus.PENDING,
+  });
+
+  const token = envelope.recipients[0].token;
+
+  const signUrl = `/sign/${token}`;
+
+  await apiSignin({
+    page,
+    email: user.email,
+    redirectPath: signUrl,
+  });
+
+  await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();
+
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(`${signUrl}/complete`);
+
+  await expect(async () => {
+    const { status } = await prisma.envelope.findFirstOrThrow({
+      where: {
+        id: envelope.id,
+      },
+    });
+
+    expect(status).toBe(DocumentStatus.COMPLETED);
+  }).toPass({
+    timeout: 10000,
+  });
+
+  const completedDocument = await prisma.envelope.findFirstOrThrow({
+    where: {
+      id: envelope.id,
+    },
+    include: {
+      envelopeItems: {
+        orderBy: {
+          order: 'asc',
+        },
+        include: {
+          documentData: true,
+        },
+      },
+    },
+  });
+
+  const storedImages = fs.readdirSync(path.join(__dirname, '../../visual-regression'));
+
+  await Promise.all(
+    completedDocument.envelopeItems.map(async (item) => {
+      const pdfData = await getFile(item.documentData);
+
+      const loadedImages = storedImages
+        .filter((image) => image.includes(item.title))
+        .map((image) => fs.readFileSync(path.join(__dirname, '../../visual-regression', image)));
+
+      await compareSignedPdfWithImages({
+        id: item.title.replaceAll(' ', '-').toLowerCase(),
+        pdfData,
+        images: loadedImages,
+        testInfo,
+      });
+    }),
+  );
+});
+
+/**
+ * Used to download the envelope images when updating the visual regression test.
+ *
+ * DON'T COMMIT THIS WITHOUT THE "SKIP" COMMAND.
+ */
+test.skip('download envelope images', async ({ page }) => {
+  const { user, team } = await seedUser();
+
+  const envelope = await seedAlignmentTestDocument({
+    userId: user.id,
+    teamId: team.id,
+    recipientName: user.name || '',
+    recipientEmail: user.email,
+    insertFields: true,
+    status: DocumentStatus.PENDING,
+  });
+
+  const token = envelope.recipients[0].token;
+
+  const signUrl = `/sign/${token}`;
+
+  await apiSignin({
+    page,
+    email: user.email,
+    redirectPath: signUrl,
+  });
+
+  await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();
+
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Sign' }).click();
+  await page.waitForURL(`${signUrl}/complete`);
+
+  await expect(async () => {
+    const { status } = await prisma.envelope.findFirstOrThrow({
+      where: {
+        id: envelope.id,
+      },
+    });
+
+    expect(status).toBe(DocumentStatus.COMPLETED);
+  }).toPass({
+    timeout: 10000,
+  });
+
+  const completedDocument = await prisma.envelope.findFirstOrThrow({
+    where: {
+      id: envelope.id,
+    },
+    include: {
+      envelopeItems: {
+        orderBy: {
+          order: 'asc',
+        },
+        include: {
+          documentData: true,
+        },
+      },
+    },
+  });
+
+  await Promise.all(
+    completedDocument.envelopeItems.map(async (item) => {
+      const pdfData = await getFile(item.documentData);
+
+      const pdfImages = await renderPdfToImage(pdfData);
+
+      for (const [index, { image }] of pdfImages.entries()) {
+        fs.writeFileSync(
+          path.join(__dirname, '../../visual-regression', `${item.title}-${index}.png`),
+          new Uint8Array(image),
+        );
+      }
+    }),
+  );
+});
+
+async function renderPdfToImage(pdfBytes: Uint8Array) {
+  const loadingTask = pdfjsLib.getDocument({ data: pdfBytes });
+  const pdf = await loadingTask.promise;
+
+  // Increase for higher resolution
+  const scale = 4;
+
+  return await Promise.all(
+    Array.from({ length: pdf.numPages }, async (_, index) => {
+      const page = await pdf.getPage(index + 1);
+
+      const viewport = page.getViewport({ scale });
+
+      const virtualCanvas = new Canvas(viewport.width, viewport.height);
+      const context = virtualCanvas.getContext('2d');
+      context.imageSmoothingEnabled = false;
+
+      // @ts-expect-error skia-canvas context satisfies runtime requirements for pdfjs
+      await page.render({ canvasContext: context, viewport }).promise;
+
+      return {
+        image: await virtualCanvas.toBuffer('png'),
+
+        // Rounded down because the certificate page somehow gives dimensions with decimals
+        width: Math.floor(viewport.width),
+        height: Math.floor(viewport.height),
+      };
+    }),
+  );
+}
+
+type CompareSignedPdfWithImagesOptions = {
+  id: string;
+  pdfData: Uint8Array;
+  images: Buffer[];
+  testInfo: TestInfo;
+};
+
+const compareSignedPdfWithImages = async ({
+  id,
+  pdfData,
+  images,
+  testInfo,
+}: CompareSignedPdfWithImagesOptions) => {
+  const renderedImages = await renderPdfToImage(pdfData);
+
+  const blankCertificateFile = fs.readFileSync(
+    path.join(__dirname, '../../visual-regression/blank-certificate.png'),
+  );
+  const blankCertificateImage = PNG.sync.read(blankCertificateFile).data;
+
+  for (const [index, { image, width, height }] of renderedImages.entries()) {
+    const isCertificate = index === renderedImages.length - 1;
+
+    const diff = new PNG({ width, height });
+
+    const storedImage = PNG.sync.read(images[index]).data;
+
+    const newImage = PNG.sync.read(image).data;
+
+    const oldImage = isCertificate ? blankCertificateImage : storedImage;
+
+    const comparison = pixelMatch(
+      new Uint8Array(oldImage),
+      new Uint8Array(newImage),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      diff.data as unknown as Uint8Array,
+      width,
+      height,
+      {
+        threshold: 0.25,
+        // includeAA: true, // This allows stricter testing.
+      },
+    );
+    console.log(`${id}-${index}: ${comparison}`);
+
+    const diffFilePath = path.join(testInfo.outputPath(), `${id}-${index}-diff.png`);
+    const oldFilePath = path.join(testInfo.outputPath(), `${id}-${index}-old.png`);
+    const newFilePath = path.join(testInfo.outputPath(), `${id}-${index}-new.png`);
+
+    fs.writeFileSync(diffFilePath, new Uint8Array(PNG.sync.write(diff)));
+    fs.writeFileSync(oldFilePath, new Uint8Array(images[index]));
+    fs.writeFileSync(newFilePath, new Uint8Array(image));
+
+    if (isCertificate) {
+      // Expect the certificate to NOT be blank. Since the storedImage is blank.
+      expect.soft(comparison).toBeGreaterThan(20000);
+    } else {
+      expect.soft(comparison).toEqual(0);
+    }
+  }
+};

packages/app-tests/package.json

@@ -15,7 +15,10 @@
     "@documenso/lib": "*",
     "@documenso/prisma": "*",
     "@playwright/test": "1.52.0",
-    "@types/node": "^20"
+    "@types/node": "^20",
+    "@types/pngjs": "^6.0.5",
+    "pixelmatch": "^7.1.0",
+    "pngjs": "^7.0.0"
   },
   "dependencies": {
     "start-server-and-test": "^2.0.12"

packages/auth/package.json

@@ -20,6 +20,6 @@
     "luxon": "^3.5.0",
     "nanoid": "^5.1.5",
     "ts-pattern": "^5.0.5",
-    "zod": "3.24.1"
+    "zod": "^3.25.76"
   }
 }

packages/ee/package.json

@@ -19,6 +19,6 @@
     "micro": "^10.0.1",
     "react": "^18",
     "ts-pattern": "^5.0.5",
-    "zod": "3.24.1"
+    "zod": "^3.25.76"
   }
 }

packages/lib/client-only/providers/envelope-editor-provider.tsx

@@ -215,7 +215,6 @@ export const EnvelopeEditorProvider = ({
   } = useEnvelopeAutosave(async (envelopeUpdates: UpdateEnvelopePayload) => {
     await envelopeUpdateMutationQuery.mutateAsync({
       envelopeId: envelope.id,
-      envelopeType: envelope.type,
       data: envelopeUpdates.data,
       meta: envelopeUpdates.meta,
     });

packages/lib/package.json

@@ -55,11 +55,11 @@
     "skia-canvas": "^3.0.8",
     "stripe": "^12.7.0",
     "ts-pattern": "^5.0.5",
-    "zod": "3.24.1"
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@playwright/browser-chromium": "1.52.0",
     "@types/luxon": "^3.3.1",
     "@types/pg": "^8.11.4"
   }
-}
+}

packages/lib/server-only/document/send-document.ts

@@ -20,7 +20,12 @@ import { validateCheckboxLength } from '../../advanced-fields-validation/validat
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { jobs } from '../../jobs/client';
 import { extractDerivedDocumentEmailSettings } from '../../types/document-email';
-import { ZCheckboxFieldMeta, ZDropdownFieldMeta, ZRadioFieldMeta } from '../../types/field-meta';
+import {
+  ZCheckboxFieldMeta,
+  ZDropdownFieldMeta,
+  ZFieldAndMetaSchema,
+  ZRadioFieldMeta,
+} from '../../types/field-meta';
 import {
   ZWebhookDocumentSchema,
   mapEnvelopeToWebhookDocumentPayload,
@@ -174,9 +179,20 @@ export const sendDocument = async ({
 
   const fieldsToAutoInsert: { fieldId: number; customText: string }[] = [];
 
-  // Auto insert radio and checkboxes that have default values.
+  // Validate and autoinsert fields for V2 envelopes.
   if (envelope.internalVersion === 2) {
-    for (const field of envelope.fields) {
+    for (const unknownField of envelope.fields) {
+      const parsedField = ZFieldAndMetaSchema.safeParse(unknownField);
+
+      if (parsedField.error) {
+        throw new AppError(AppErrorCode.INVALID_REQUEST, {
+          message: 'One or more fields have invalid metadata. Error: ' + parsedField.error.message,
+        });
+      }
+
+      const field = parsedField.data;
+      const fieldId = unknownField.id;
+
       if (field.type === FieldType.RADIO) {
         const { values = [] } = ZRadioFieldMeta.parse(field.fieldMeta);
 
@@ -184,7 +200,7 @@ export const sendDocument = async ({
 
         if (checkedItemIndex !== -1) {
           fieldsToAutoInsert.push({
-            fieldId: field.id,
+            fieldId,
             customText: toRadioCustomText(checkedItemIndex),
           });
         }
@@ -195,7 +211,7 @@ export const sendDocument = async ({
 
         if (defaultValue && values.some((value) => value.value === defaultValue)) {
           fieldsToAutoInsert.push({
-            fieldId: field.id,
+            fieldId,
             customText: defaultValue,
           });
         }
@@ -236,7 +252,7 @@ export const sendDocument = async ({
 
         if (isValid) {
           fieldsToAutoInsert.push({
-            fieldId: field.id,
+            fieldId,
             customText: toCheckboxCustomText(checkedIndices),
           });
         }

packages/lib/server-only/envelope/create-envelope.ts

@@ -16,11 +16,16 @@ import type { ApiRequestMetadata } from '@documenso/lib/universal/extract-reques
 import { nanoid, prefixedId } from '@documenso/lib/universal/id';
 import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
 import { prisma } from '@documenso/prisma';
-import type { TCreateEnvelopeRequest } from '@documenso/trpc/server/envelope-router/create-envelope.types';
 
-import type { TDocumentAccessAuthTypes, TDocumentActionAuthTypes } from '../../types/document-auth';
+import type {
+  TDocumentAccessAuthTypes,
+  TDocumentActionAuthTypes,
+  TRecipientAccessAuthTypes,
+  TRecipientActionAuthTypes,
+} from '../../types/document-auth';
 import type { TDocumentFormValues } from '../../types/document-form-values';
 import type { TEnvelopeAttachmentType } from '../../types/envelope-attachment';
+import type { TFieldAndMeta } from '../../types/field-meta';
 import {
   ZWebhookDocumentSchema,
   mapEnvelopeToWebhookDocumentPayload,
@@ -34,6 +39,25 @@ import { incrementDocumentId, incrementTemplateId } from '../envelope/increment-
 import { getTeamSettings } from '../team/get-team-settings';
 import { triggerWebhook } from '../webhooks/trigger/trigger-webhook';
 
+type CreateEnvelopeRecipientFieldOptions = TFieldAndMeta & {
+  documentDataId: string;
+  page: number;
+  positionX: number;
+  positionY: number;
+  width: number;
+  height: number;
+};
+
+type CreateEnvelopeRecipientOptions = {
+  email: string;
+  name: string;
+  role: RecipientRole;
+  signingOrder?: number;
+  accessAuth?: TRecipientAccessAuthTypes[];
+  actionAuth?: TRecipientActionAuthTypes[];
+  fields?: CreateEnvelopeRecipientFieldOptions[];
+};
+
 export type CreateEnvelopeOptions = {
   userId: number;
   teamId: number;
@@ -56,7 +80,7 @@ export type CreateEnvelopeOptions = {
     visibility?: DocumentVisibility;
     globalAccessAuth?: TDocumentAccessAuthTypes[];
     globalActionAuth?: TDocumentActionAuthTypes[];
-    recipients?: TCreateEnvelopeRequest['recipients'];
+    recipients?: CreateEnvelopeRecipientOptions[];
     folderId?: string;
   };
   attachments?: Array<{

packages/lib/server-only/field/create-envelope-fields.ts

@@ -26,9 +26,9 @@ export interface CreateEnvelopeFieldsOptions {
     envelopeItemId?: string;
 
     recipientId: number;
-    pageNumber: number;
-    pageX: number;
-    pageY: number;
+    page: number;
+    positionX: number;
+    positionY: number;
     width: number;
     height: number;
   })[];
@@ -122,9 +122,9 @@ export const createEnvelopeFields = async ({
     const newlyCreatedFields = await tx.field.createManyAndReturn({
       data: validatedFields.map((field) => ({
         type: field.type,
-        page: field.pageNumber,
-        positionX: field.pageX,
-        positionY: field.pageY,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
         width: field.width,
         height: field.height,
         customText: '',

packages/lib/server-only/field/get-field-by-id.ts

@@ -11,7 +11,7 @@ export type GetFieldByIdOptions = {
   userId: number;
   teamId: number;
   fieldId: number;
-  envelopeType: EnvelopeType;
+  envelopeType?: EnvelopeType;
 };
 
 export const getFieldById = async ({
@@ -41,7 +41,7 @@ export const getFieldById = async ({
       type: 'envelopeId',
       id: field.envelopeId,
     },
-    type: envelopeType,
+    type: envelopeType ?? null,
     userId,
     teamId,
   });

packages/lib/server-only/field/set-fields-for-document.ts

@@ -158,7 +158,7 @@ export const setFieldsForDocument = async ({
           const numberFieldParsedMeta = ZNumberFieldMeta.parse(field.fieldMeta);
 
           const errors = validateNumberField(
-            String(numberFieldParsedMeta.value),
+            String(numberFieldParsedMeta.value || ''),
             numberFieldParsedMeta,
             false,
           );

packages/lib/server-only/field/update-envelope-fields.ts

@@ -10,18 +10,21 @@ import {
 import { prisma } from '@documenso/prisma';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
+import { type EnvelopeIdOptions } from '../../utils/envelope';
 import { mapFieldToLegacyField } from '../../utils/fields';
 import { canRecipientFieldsBeModified } from '../../utils/recipients';
 import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface UpdateDocumentFieldsOptions {
+export interface UpdateEnvelopeFieldsOptions {
   userId: number;
   teamId: number;
-  documentId: number;
+  id: EnvelopeIdOptions;
+  type?: EnvelopeType | null; // Only used to enforce the type.
   fields: {
     id: number;
     type?: FieldType;
     pageNumber?: number;
+    envelopeItemId?: string;
     pageX?: number;
     pageY?: number;
     width?: number;
@@ -31,19 +34,17 @@ export interface UpdateDocumentFieldsOptions {
   requestMetadata: ApiRequestMetadata;
 }
 
-export const updateDocumentFields = async ({
+export const updateEnvelopeFields = async ({
   userId,
   teamId,
-  documentId,
+  id,
+  type = null,
   fields,
   requestMetadata,
-}: UpdateDocumentFieldsOptions) => {
+}: UpdateEnvelopeFieldsOptions) => {
   const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'documentId',
-      id: documentId,
-    },
-    type: EnvelopeType.DOCUMENT,
+    id,
+    type,
     userId,
     teamId,
   });
@@ -53,18 +54,19 @@ export const updateDocumentFields = async ({
     include: {
       recipients: true,
       fields: true,
+      envelopeItems: true,
     },
   });
 
   if (!envelope) {
     throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
+      message: 'Envelope not found',
     });
   }
 
   if (envelope.completedAt) {
     throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Document already complete',
+      message: 'Envelope already complete',
     });
   }
 
@@ -96,6 +98,29 @@ export const updateDocumentFields = async ({
       });
     }
 
+    const fieldType = field.type || originalField.type;
+    const fieldMetaType = field.fieldMeta?.type || originalField.fieldMeta?.type;
+
+    // Not going to mess with V1 envelopes.
+    if (
+      envelope.internalVersion === 2 &&
+      fieldMetaType &&
+      fieldMetaType.toLowerCase() !== fieldType.toLowerCase()
+    ) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Field meta type does not match the field type',
+      });
+    }
+
+    if (
+      field.envelopeItemId &&
+      !envelope.envelopeItems.some((item) => item.id === field.envelopeItemId)
+    ) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope item not found',
+      });
+    }
+
     return {
       originalField,
       updateData: field,
@@ -118,27 +143,30 @@ export const updateDocumentFields = async ({
             width: updateData.width,
             height: updateData.height,
             fieldMeta: updateData.fieldMeta,
+            envelopeItemId: updateData.envelopeItemId,
           },
         });
 
-        const changes = diffFieldChanges(originalField, updatedField);
-
         // Handle field updated audit log.
-        if (changes.length > 0) {
-          await tx.documentAuditLog.create({
-            data: createDocumentAuditLogData({
-              type: DOCUMENT_AUDIT_LOG_TYPE.FIELD_UPDATED,
-              envelopeId: envelope.id,
-              metadata: requestMetadata,
-              data: {
-                fieldId: updatedField.secondaryId,
-                fieldRecipientEmail: recipientEmail,
-                fieldRecipientId: updatedField.recipientId,
-                fieldType: updatedField.type,
-                changes,
-              },
-            }),
-          });
+        if (envelope.type === EnvelopeType.DOCUMENT) {
+          const changes = diffFieldChanges(originalField, updatedField);
+
+          if (changes.length > 0) {
+            await tx.documentAuditLog.create({
+              data: createDocumentAuditLogData({
+                type: DOCUMENT_AUDIT_LOG_TYPE.FIELD_UPDATED,
+                envelopeId: envelope.id,
+                metadata: requestMetadata,
+                data: {
+                  fieldId: updatedField.secondaryId,
+                  fieldRecipientEmail: recipientEmail,
+                  fieldRecipientId: updatedField.recipientId,
+                  fieldType: updatedField.type,
+                  changes,
+                },
+              }),
+            });
+          }
         }
 
         return updatedField;

packages/lib/server-only/field/update-template-fields.ts

@@ -1,116 +0,0 @@
-import { EnvelopeType, type FieldType } from '@prisma/client';
-
-import type { TFieldMetaSchema } from '@documenso/lib/types/field-meta';
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { mapFieldToLegacyField } from '../../utils/fields';
-import { canRecipientFieldsBeModified } from '../../utils/recipients';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface UpdateTemplateFieldsOptions {
-  userId: number;
-  teamId: number;
-  templateId: number;
-  fields: {
-    id: number;
-    type?: FieldType;
-    pageNumber?: number;
-    pageX?: number;
-    pageY?: number;
-    width?: number;
-    height?: number;
-    fieldMeta?: TFieldMetaSchema;
-  }[];
-}
-
-export const updateTemplateFields = async ({
-  userId,
-  teamId,
-  templateId,
-  fields,
-}: UpdateTemplateFieldsOptions) => {
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'templateId',
-      id: templateId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  const envelope = await prisma.envelope.findFirst({
-    where: envelopeWhereInput,
-    include: {
-      recipients: true,
-      fields: true,
-    },
-  });
-
-  if (!envelope) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
-    });
-  }
-
-  const fieldsToUpdate = fields.map((field) => {
-    const originalField = envelope.fields.find((existingField) => existingField.id === field.id);
-
-    if (!originalField) {
-      throw new AppError(AppErrorCode.NOT_FOUND, {
-        message: `Field with id ${field.id} not found`,
-      });
-    }
-
-    const recipient = envelope.recipients.find(
-      (recipient) => recipient.id === originalField.recipientId,
-    );
-
-    // Each field MUST have a recipient associated with it.
-    if (!recipient) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message: `Recipient attached to field ${field.id} not found`,
-      });
-    }
-
-    // Check whether the recipient associated with the field can be modified.
-    if (!canRecipientFieldsBeModified(recipient, envelope.fields)) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message:
-          'Cannot modify a field where the recipient has already interacted with the document',
-      });
-    }
-
-    return {
-      updateData: field,
-    };
-  });
-
-  const updatedFields = await prisma.$transaction(async (tx) => {
-    return await Promise.all(
-      fieldsToUpdate.map(async ({ updateData }) => {
-        const updatedField = await tx.field.update({
-          where: {
-            id: updateData.id,
-          },
-          data: {
-            type: updateData.type,
-            page: updateData.pageNumber,
-            positionX: updateData.pageX,
-            positionY: updateData.pageY,
-            width: updateData.width,
-            height: updateData.height,
-            fieldMeta: updateData.fieldMeta,
-          },
-        });
-
-        return updatedField;
-      }),
-    );
-  });
-
-  return {
-    fields: updatedFields.map((field) => mapFieldToLegacyField(field, envelope)),
-  };
-};

packages/lib/server-only/pdf/normalize-pdf.ts

@@ -1,13 +1,22 @@
 import { PDFDocument } from '@cantoo/pdf-lib';
 
+import { AppError } from '../../errors/app-error';
 import { flattenAnnotations } from './flatten-annotations';
 import { flattenForm, removeOptionalContentGroups } from './flatten-form';
 
 export const normalizePdf = async (pdf: Buffer) => {
-  const pdfDoc = await PDFDocument.load(pdf).catch(() => null);
+  const pdfDoc = await PDFDocument.load(pdf).catch((e) => {
+    console.error(`PDF normalization error: ${e.message}`);
 
-  if (!pdfDoc) {
-    return pdf;
+    throw new AppError('INVALID_DOCUMENT_FILE', {
+      message: 'The document is not a valid PDF',
+    });
+  });
+
+  if (pdfDoc.isEncrypted) {
+    throw new AppError('INVALID_DOCUMENT_FILE', {
+      message: 'The document is encrypted',
+    });
   }
 
   removeOptionalContentGroups(pdfDoc);

packages/lib/server-only/recipient/create-envelope-recipients.ts

@@ -15,7 +15,7 @@ import type { EnvelopeIdOptions } from '../../utils/envelope';
 import { mapRecipientToLegacyRecipient } from '../../utils/recipients';
 import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface CreateDocumentRecipientsOptions {
+export interface CreateEnvelopeRecipientsOptions {
   userId: number;
   teamId: number;
   id: EnvelopeIdOptions;
@@ -30,16 +30,16 @@ export interface CreateDocumentRecipientsOptions {
   requestMetadata: ApiRequestMetadata;
 }
 
-export const createDocumentRecipients = async ({
+export const createEnvelopeRecipients = async ({
   userId,
   teamId,
   id,
   recipients: recipientsToCreate,
   requestMetadata,
-}: CreateDocumentRecipientsOptions) => {
+}: CreateEnvelopeRecipientsOptions) => {
   const { envelopeWhereInput } = await getEnvelopeWhereInput({
     id,
-    type: EnvelopeType.DOCUMENT,
+    type: null,
     userId,
     teamId,
   });
@@ -62,13 +62,13 @@ export const createDocumentRecipients = async ({
 
   if (!envelope) {
     throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
+      message: 'Envelope not found',
     });
   }
 
   if (envelope.completedAt) {
     throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Document already complete',
+      message: 'Envelope already complete',
     });
   }
 
@@ -112,21 +112,23 @@ export const createDocumentRecipients = async ({
         });
 
         // Handle recipient created audit log.
-        await tx.documentAuditLog.create({
-          data: createDocumentAuditLogData({
-            type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_CREATED,
-            envelopeId: envelope.id,
-            metadata: requestMetadata,
-            data: {
-              recipientEmail: createdRecipient.email,
-              recipientName: createdRecipient.name,
-              recipientId: createdRecipient.id,
-              recipientRole: createdRecipient.role,
-              accessAuth: recipient.accessAuth ?? [],
-              actionAuth: recipient.actionAuth ?? [],
-            },
-          }),
-        });
+        if (envelope.type === EnvelopeType.DOCUMENT) {
+          await tx.documentAuditLog.create({
+            data: createDocumentAuditLogData({
+              type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_CREATED,
+              envelopeId: envelope.id,
+              metadata: requestMetadata,
+              data: {
+                recipientEmail: createdRecipient.email,
+                recipientName: createdRecipient.name,
+                recipientId: createdRecipient.id,
+                recipientRole: createdRecipient.role,
+                accessAuth: recipient.accessAuth ?? [],
+                actionAuth: recipient.actionAuth ?? [],
+              },
+            }),
+          });
+        }
 
         return createdRecipient;
       }),

packages/lib/server-only/recipient/create-template-recipients.ts

@@ -1,115 +0,0 @@
-import { EnvelopeType, RecipientRole } from '@prisma/client';
-import { SendStatus, SigningStatus } from '@prisma/client';
-
-import type { TRecipientAccessAuthTypes } from '@documenso/lib/types/document-auth';
-import { type TRecipientActionAuthTypes } from '@documenso/lib/types/document-auth';
-import { nanoid } from '@documenso/lib/universal/id';
-import { createRecipientAuthOptions } from '@documenso/lib/utils/document-auth';
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { mapRecipientToLegacyRecipient } from '../../utils/recipients';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface CreateTemplateRecipientsOptions {
-  userId: number;
-  teamId: number;
-  templateId: number;
-  recipients: {
-    email: string;
-    name: string;
-    role: RecipientRole;
-    signingOrder?: number | null;
-    accessAuth?: TRecipientAccessAuthTypes[];
-    actionAuth?: TRecipientActionAuthTypes[];
-  }[];
-}
-
-export const createTemplateRecipients = async ({
-  userId,
-  teamId,
-  templateId,
-  recipients: recipientsToCreate,
-}: CreateTemplateRecipientsOptions) => {
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'templateId',
-      id: templateId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  const template = await prisma.envelope.findFirst({
-    where: envelopeWhereInput,
-    include: {
-      recipients: true,
-      team: {
-        select: {
-          organisation: {
-            select: {
-              organisationClaim: true,
-            },
-          },
-        },
-      },
-    },
-  });
-
-  if (!template) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Template not found',
-    });
-  }
-
-  const recipientsHaveActionAuth = recipientsToCreate.some(
-    (recipient) => recipient.actionAuth && recipient.actionAuth.length > 0,
-  );
-
-  // Check if user has permission to set the global action auth.
-  if (recipientsHaveActionAuth && !template.team.organisation.organisationClaim.flags.cfr21) {
-    throw new AppError(AppErrorCode.UNAUTHORIZED, {
-      message: 'You do not have permission to set the action auth',
-    });
-  }
-
-  const normalizedRecipients = recipientsToCreate.map((recipient) => ({
-    ...recipient,
-    email: recipient.email.toLowerCase(),
-  }));
-
-  const createdRecipients = await prisma.$transaction(async (tx) => {
-    return await Promise.all(
-      normalizedRecipients.map(async (recipient) => {
-        const authOptions = createRecipientAuthOptions({
-          accessAuth: recipient.accessAuth ?? [],
-          actionAuth: recipient.actionAuth ?? [],
-        });
-
-        const createdRecipient = await tx.recipient.create({
-          data: {
-            envelopeId: template.id,
-            name: recipient.name,
-            email: recipient.email,
-            role: recipient.role,
-            signingOrder: recipient.signingOrder,
-            token: nanoid(),
-            sendStatus: recipient.role === RecipientRole.CC ? SendStatus.SENT : SendStatus.NOT_SENT,
-            signingStatus:
-              recipient.role === RecipientRole.CC ? SigningStatus.SIGNED : SigningStatus.NOT_SIGNED,
-            authOptions,
-          },
-        });
-
-        return createdRecipient;
-      }),
-    );
-  });
-
-  return {
-    recipients: createdRecipients.map((recipient) =>
-      mapRecipientToLegacyRecipient(recipient, template),
-    ),
-  };
-};

packages/lib/server-only/recipient/delete-envelope-recipient.ts

@@ -14,26 +14,27 @@ import { NEXT_PUBLIC_WEBAPP_URL } from '../../constants/app';
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { extractDerivedDocumentEmailSettings } from '../../types/document-email';
 import { createDocumentAuditLogData } from '../../utils/document-audit-logs';
+import { canRecipientBeModified } from '../../utils/recipients';
 import { renderEmailWithI18N } from '../../utils/render-email-with-i18n';
 import { buildTeamWhereQuery } from '../../utils/teams';
 import { getEmailContext } from '../email/get-email-context';
+import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface DeleteDocumentRecipientOptions {
+export interface DeleteEnvelopeRecipientOptions {
   userId: number;
   teamId: number;
   recipientId: number;
   requestMetadata: ApiRequestMetadata;
 }
 
-export const deleteDocumentRecipient = async ({
+export const deleteEnvelopeRecipient = async ({
   userId,
   teamId,
   recipientId,
   requestMetadata,
-}: DeleteDocumentRecipientOptions) => {
+}: DeleteEnvelopeRecipientOptions) => {
   const envelope = await prisma.envelope.findFirst({
     where: {
-      type: EnvelopeType.DOCUMENT,
       recipients: {
         some: {
           id: recipientId,
@@ -48,6 +49,9 @@ export const deleteDocumentRecipient = async ({
         where: {
           id: recipientId,
         },
+        include: {
+          fields: true,
+        },
       },
     },
   });
@@ -89,24 +93,43 @@ export const deleteDocumentRecipient = async ({
     });
   }
 
-  const deletedRecipient = await prisma.$transaction(async (tx) => {
-    await tx.documentAuditLog.create({
-      data: createDocumentAuditLogData({
-        type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_DELETED,
-        envelopeId: envelope.id,
-        metadata: requestMetadata,
-        data: {
-          recipientEmail: recipientToDelete.email,
-          recipientName: recipientToDelete.name,
-          recipientId: recipientToDelete.id,
-          recipientRole: recipientToDelete.role,
-        },
-      }),
+  if (!canRecipientBeModified(recipientToDelete, recipientToDelete.fields)) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Recipient has already interacted with the document.',
     });
+  }
+
+  const { envelopeWhereInput } = await getEnvelopeWhereInput({
+    id: {
+      type: 'envelopeId',
+      id: envelope.id,
+    },
+    type: null,
+    userId,
+    teamId,
+  });
+
+  const deletedRecipient = await prisma.$transaction(async (tx) => {
+    if (envelope.type === EnvelopeType.DOCUMENT) {
+      await tx.documentAuditLog.create({
+        data: createDocumentAuditLogData({
+          type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_DELETED,
+          envelopeId: envelope.id,
+          metadata: requestMetadata,
+          data: {
+            recipientEmail: recipientToDelete.email,
+            recipientName: recipientToDelete.name,
+            recipientId: recipientToDelete.id,
+            recipientRole: recipientToDelete.role,
+          },
+        }),
+      });
+    }
 
     return await tx.recipient.delete({
       where: {
         id: recipientId,
+        envelope: envelopeWhereInput,
       },
     });
   });
@@ -116,7 +139,11 @@ export const deleteDocumentRecipient = async ({
   ).recipientRemoved;
 
   // Send email to deleted recipient.
-  if (recipientToDelete.sendStatus === SendStatus.SENT && isRecipientRemovedEmailEnabled) {
+  if (
+    recipientToDelete.sendStatus === SendStatus.SENT &&
+    isRecipientRemovedEmailEnabled &&
+    envelope.type === EnvelopeType.DOCUMENT
+  ) {
     const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
 
     const template = createElement(RecipientRemovedFromDocumentTemplate, {

packages/lib/server-only/recipient/delete-template-recipient.ts

@@ -1,58 +0,0 @@
-import { EnvelopeType } from '@prisma/client';
-
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { buildTeamWhereQuery } from '../../utils/teams';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface DeleteTemplateRecipientOptions {
-  userId: number;
-  teamId: number;
-  recipientId: number;
-}
-
-export const deleteTemplateRecipient = async ({
-  userId,
-  teamId,
-  recipientId,
-}: DeleteTemplateRecipientOptions): Promise<void> => {
-  const recipientToDelete = await prisma.recipient.findFirst({
-    where: {
-      id: recipientId,
-      envelope: {
-        type: EnvelopeType.TEMPLATE,
-        team: buildTeamWhereQuery({ teamId, userId }),
-      },
-    },
-  });
-
-  if (!recipientToDelete) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Recipient not found',
-    });
-  }
-
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'envelopeId',
-      id: recipientToDelete.envelopeId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  if (!recipientToDelete || recipientToDelete.id !== recipientId) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Recipient not found',
-    });
-  }
-
-  await prisma.recipient.delete({
-    where: {
-      id: recipientId,
-      envelope: envelopeWhereInput,
-    },
-  });
-};

packages/lib/server-only/recipient/update-envelope-recipients.ts

@@ -1,5 +1,4 @@
-import { EnvelopeType, RecipientRole } from '@prisma/client';
-import { SendStatus, SigningStatus } from '@prisma/client';
+import { EnvelopeType, RecipientRole, SendStatus, SigningStatus } from '@prisma/client';
 
 import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
 import type { TRecipientAccessAuthTypes } from '@documenso/lib/types/document-auth';
@@ -16,29 +15,38 @@ import { createRecipientAuthOptions } from '@documenso/lib/utils/document-auth';
 import { prisma } from '@documenso/prisma';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
-import { type EnvelopeIdOptions, mapSecondaryIdToDocumentId } from '../../utils/envelope';
+import { extractLegacyIds } from '../../universal/id';
+import { type EnvelopeIdOptions } from '../../utils/envelope';
 import { mapFieldToLegacyField } from '../../utils/fields';
 import { canRecipientBeModified } from '../../utils/recipients';
 import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
 
-export interface UpdateDocumentRecipientsOptions {
+export interface UpdateEnvelopeRecipientsOptions {
   userId: number;
   teamId: number;
   id: EnvelopeIdOptions;
-  recipients: RecipientData[];
+  recipients: {
+    id: number;
+    email?: string;
+    name?: string;
+    role?: RecipientRole;
+    signingOrder?: number | null;
+    accessAuth?: TRecipientAccessAuthTypes[];
+    actionAuth?: TRecipientActionAuthTypes[];
+  }[];
   requestMetadata: ApiRequestMetadata;
 }
 
-export const updateDocumentRecipients = async ({
+export const updateEnvelopeRecipients = async ({
   userId,
   teamId,
   id,
   recipients,
   requestMetadata,
-}: UpdateDocumentRecipientsOptions) => {
+}: UpdateEnvelopeRecipientsOptions) => {
   const { envelopeWhereInput } = await getEnvelopeWhereInput({
     id,
-    type: EnvelopeType.DOCUMENT,
+    type: null,
     userId,
     teamId,
   });
@@ -62,13 +70,13 @@ export const updateDocumentRecipients = async ({
 
   if (!envelope) {
     throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Document not found',
+      message: 'Envelope not found',
     });
   }
 
   if (envelope.completedAt) {
     throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Document already complete',
+      message: 'Envelope already complete',
     });
   }
 
@@ -160,24 +168,26 @@ export const updateDocumentRecipients = async ({
           });
         }
 
-        const changes = diffRecipientChanges(originalRecipient, updatedRecipient);
-
         // Handle recipient updated audit log.
-        if (changes.length > 0) {
-          await tx.documentAuditLog.create({
-            data: createDocumentAuditLogData({
-              type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_UPDATED,
-              envelopeId: envelope.id,
-              metadata: requestMetadata,
-              data: {
-                recipientEmail: updatedRecipient.email,
-                recipientName: updatedRecipient.name,
-                recipientId: updatedRecipient.id,
-                recipientRole: updatedRecipient.role,
-                changes,
-              },
-            }),
-          });
+        if (envelope.type === EnvelopeType.DOCUMENT) {
+          const changes = diffRecipientChanges(originalRecipient, updatedRecipient);
+
+          if (changes.length > 0) {
+            await tx.documentAuditLog.create({
+              data: createDocumentAuditLogData({
+                type: DOCUMENT_AUDIT_LOG_TYPE.RECIPIENT_UPDATED,
+                envelopeId: envelope.id,
+                metadata: requestMetadata,
+                data: {
+                  recipientEmail: updatedRecipient.email,
+                  recipientName: updatedRecipient.name,
+                  recipientId: updatedRecipient.id,
+                  recipientRole: updatedRecipient.role,
+                  changes,
+                },
+              }),
+            });
+          }
         }
 
         return updatedRecipient;
@@ -188,19 +198,8 @@ export const updateDocumentRecipients = async ({
   return {
     recipients: updatedRecipients.map((recipient) => ({
       ...recipient,
-      documentId: mapSecondaryIdToDocumentId(envelope.secondaryId),
-      templateId: null,
+      ...extractLegacyIds(envelope),
       fields: recipient.fields.map((field) => mapFieldToLegacyField(field, envelope)),
     })),
   };
 };
-
-type RecipientData = {
-  id: number;
-  email?: string;
-  name?: string;
-  role?: RecipientRole;
-  signingOrder?: number | null;
-  accessAuth?: TRecipientAccessAuthTypes[];
-  actionAuth?: TRecipientActionAuthTypes[];
-};

packages/lib/server-only/recipient/update-template-recipients.ts

@@ -1,168 +0,0 @@
-import { EnvelopeType, RecipientRole } from '@prisma/client';
-import { SendStatus, SigningStatus } from '@prisma/client';
-
-import type { TRecipientAccessAuthTypes } from '@documenso/lib/types/document-auth';
-import {
-  type TRecipientActionAuthTypes,
-  ZRecipientAuthOptionsSchema,
-} from '@documenso/lib/types/document-auth';
-import { createRecipientAuthOptions } from '@documenso/lib/utils/document-auth';
-import { prisma } from '@documenso/prisma';
-
-import { AppError, AppErrorCode } from '../../errors/app-error';
-import { mapSecondaryIdToTemplateId } from '../../utils/envelope';
-import { mapFieldToLegacyField } from '../../utils/fields';
-import { getEnvelopeWhereInput } from '../envelope/get-envelope-by-id';
-
-export interface UpdateTemplateRecipientsOptions {
-  userId: number;
-  teamId: number;
-  templateId: number;
-  recipients: {
-    id: number;
-    email?: string;
-    name?: string;
-    role?: RecipientRole;
-    signingOrder?: number | null;
-    accessAuth?: TRecipientAccessAuthTypes[];
-    actionAuth?: TRecipientActionAuthTypes[];
-  }[];
-}
-
-export const updateTemplateRecipients = async ({
-  userId,
-  teamId,
-  templateId,
-  recipients,
-}: UpdateTemplateRecipientsOptions) => {
-  const { envelopeWhereInput } = await getEnvelopeWhereInput({
-    id: {
-      type: 'templateId',
-      id: templateId,
-    },
-    type: EnvelopeType.TEMPLATE,
-    userId,
-    teamId,
-  });
-
-  const envelope = await prisma.envelope.findFirst({
-    where: envelopeWhereInput,
-    include: {
-      recipients: true,
-      team: {
-        select: {
-          organisation: {
-            select: {
-              organisationClaim: true,
-            },
-          },
-        },
-      },
-    },
-  });
-
-  if (!envelope) {
-    throw new AppError(AppErrorCode.NOT_FOUND, {
-      message: 'Template not found',
-    });
-  }
-
-  const recipientsHaveActionAuth = recipients.some(
-    (recipient) => recipient.actionAuth && recipient.actionAuth.length > 0,
-  );
-
-  // Check if user has permission to set the global action auth.
-  if (recipientsHaveActionAuth && !envelope.team.organisation.organisationClaim.flags.cfr21) {
-    throw new AppError(AppErrorCode.UNAUTHORIZED, {
-      message: 'You do not have permission to set the action auth',
-    });
-  }
-
-  const recipientsToUpdate = recipients.map((recipient) => {
-    const originalRecipient = envelope.recipients.find(
-      (existingRecipient) => existingRecipient.id === recipient.id,
-    );
-
-    if (!originalRecipient) {
-      throw new AppError(AppErrorCode.NOT_FOUND, {
-        message: `Recipient with id ${recipient.id} not found`,
-      });
-    }
-
-    return {
-      originalRecipient,
-      recipientUpdateData: recipient,
-    };
-  });
-
-  const updatedRecipients = await prisma.$transaction(async (tx) => {
-    return await Promise.all(
-      recipientsToUpdate.map(async ({ originalRecipient, recipientUpdateData }) => {
-        let authOptions = ZRecipientAuthOptionsSchema.parse(originalRecipient.authOptions);
-
-        if (
-          recipientUpdateData.actionAuth !== undefined ||
-          recipientUpdateData.accessAuth !== undefined
-        ) {
-          authOptions = createRecipientAuthOptions({
-            accessAuth: recipientUpdateData.accessAuth || authOptions.accessAuth,
-            actionAuth: recipientUpdateData.actionAuth || authOptions.actionAuth,
-          });
-        }
-
-        const mergedRecipient = {
-          ...originalRecipient,
-          ...recipientUpdateData,
-        };
-
-        const updatedRecipient = await tx.recipient.update({
-          where: {
-            id: originalRecipient.id,
-            envelopeId: envelope.id,
-          },
-          data: {
-            name: mergedRecipient.name,
-            email: mergedRecipient.email,
-            role: mergedRecipient.role,
-            signingOrder: mergedRecipient.signingOrder,
-            envelopeId: envelope.id,
-            sendStatus:
-              mergedRecipient.role === RecipientRole.CC ? SendStatus.SENT : SendStatus.NOT_SENT,
-            signingStatus:
-              mergedRecipient.role === RecipientRole.CC
-                ? SigningStatus.SIGNED
-                : SigningStatus.NOT_SIGNED,
-            authOptions,
-          },
-          include: {
-            fields: true,
-          },
-        });
-
-        // Clear all fields if the recipient role is changed to a type that cannot have fields.
-        if (
-          originalRecipient.role !== updatedRecipient.role &&
-          (updatedRecipient.role === RecipientRole.CC ||
-            updatedRecipient.role === RecipientRole.VIEWER)
-        ) {
-          await tx.field.deleteMany({
-            where: {
-              recipientId: updatedRecipient.id,
-            },
-          });
-        }
-
-        return updatedRecipient;
-      }),
-    );
-  });
-
-  return {
-    recipients: updatedRecipients.map((recipient) => ({
-      ...recipient,
-      documentId: null,
-      templateId: mapSecondaryIdToTemplateId(envelope.secondaryId),
-      fields: recipient.fields.map((field) => mapFieldToLegacyField(field, envelope)),
-    })),
-  };
-};

packages/lib/types/envelope.ts

@@ -37,11 +37,8 @@ export const ZEnvelopeSchema = EnvelopeSchema.pick({
   userId: true,
   teamId: true,
   folderId: true,
+  templateId: true,
 }).extend({
-  templateId: z
-    .number()
-    .nullish()
-    .describe('The ID of the template that the document was created from, if any.'),
   documentMeta: DocumentMetaSchema.pick({
     signingOrder: true,
     distributionMethod: true,

packages/lib/types/field-meta.ts

@@ -188,7 +188,7 @@ export type TFieldMetaSchema = z.infer<typeof ZFieldMetaSchema>;
 export const ZFieldAndMetaSchema = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(FieldType.SIGNATURE),
-    fieldMeta: z.undefined(),
+    fieldMeta: ZSignatureFieldMeta.optional(),
   }),
   z.object({
     type: z.literal(FieldType.FREE_SIGNATURE),

packages/lib/types/field.ts

@@ -50,6 +50,11 @@ export const ZFieldSchema = FieldSchema.pick({
   templateId: z.number().nullish(),
 });
 
+export const ZEnvelopeFieldSchema = ZFieldSchema.omit({
+  documentId: true,
+  templateId: true,
+});
+
 export const ZFieldPageNumberSchema = z
   .number()
   .min(1)
@@ -69,6 +74,30 @@ export const ZFieldWidthSchema = z.number().min(1).describe('The width of the fi
 
 export const ZFieldHeightSchema = z.number().min(1).describe('The height of the field.');
 
+export const ZClampedFieldPositionXSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based X coordinate where the field will be placed.');
+
+export const ZClampedFieldPositionYSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based Y coordinate where the field will be placed.');
+
+export const ZClampedFieldWidthSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based width of the field on the page.');
+
+export const ZClampedFieldHeightSchema = z
+  .number()
+  .min(0)
+  .max(100)
+  .describe('The percentage based height of the field on the page.');
+
 // ---------------------------------------------
 
 const PrismaDecimalSchema = z.preprocess(

packages/lib/types/recipient.ts

@@ -95,3 +95,18 @@ export const ZRecipientManySchema = RecipientSchema.pick({
   documentId: z.number().nullish(),
   templateId: z.number().nullish(),
 });
+
+export const ZEnvelopeRecipientSchema = ZRecipientSchema.omit({
+  documentId: true,
+  templateId: true,
+});
+
+export const ZEnvelopeRecipientLiteSchema = ZRecipientLiteSchema.omit({
+  documentId: true,
+  templateId: true,
+});
+
+export const ZEnvelopeRecipientManySchema = ZRecipientManySchema.omit({
+  documentId: true,
+  templateId: true,
+});

packages/lib/universal/field-renderer/render-checkbox-field.ts

@@ -3,6 +3,7 @@ import { match } from 'ts-pattern';
 
 import { DEFAULT_STANDARD_FONT_SIZE } from '../../constants/pdf';
 import type { TCheckboxFieldMeta } from '../../types/field-meta';
+import { parseCheckboxCustomText } from '../../utils/fields';
 import {
   createFieldHoverInteraction,
   konvaTextFill,
@@ -130,7 +131,7 @@ export const renderCheckboxFieldElement = (
     pageLayer.batchDraw();
   });
 
-  const checkedValues: number[] = field.customText ? JSON.parse(field.customText) : [];
+  const checkedValues: number[] = field.customText ? parseCheckboxCustomText(field.customText) : [];
 
   checkboxValues.forEach(({ value, checked }, index) => {
     const isCheckboxChecked = match(mode)
@@ -170,7 +171,7 @@ export const renderCheckboxFieldElement = (
       width: itemSize,
       height: itemSize,
       stroke: '#374151',
-      strokeWidth: 2,
+      strokeWidth: 1.5,
       cornerRadius: 2,
       fill: 'white',
     });

packages/lib/universal/field-renderer/render-radio-field.ts

@@ -159,7 +159,7 @@ export const renderRadioFieldElement = (
       y: itemInputY,
       radius: calculateRadioSize(fontSize) / 2,
       stroke: '#374151',
-      strokeWidth: 2,
+      strokeWidth: 1.5,
       fill: 'white',
     });
 

packages/lib/universal/upload/put-file.server.ts

@@ -7,6 +7,7 @@ import { env } from '@documenso/lib/utils/env';
 
 import { AppError } from '../../errors/app-error';
 import { createDocumentData } from '../../server-only/document-data/create-document-data';
+import { normalizePdf } from '../../server-only/pdf/normalize-pdf';
 import { uploadS3File } from './server-actions';
 
 type File = {
@@ -43,6 +44,28 @@ export const putPdfFileServerSide = async (file: File) => {
   return await createDocumentData({ type, data });
 };
 
+/**
+ * Uploads a pdf file and normalizes it.
+ */
+export const putNormalizedPdfFileServerSide = async (file: File) => {
+  const buffer = Buffer.from(await file.arrayBuffer());
+
+  const normalized = await normalizePdf(buffer);
+
+  const fileName = file.name.endsWith('.pdf') ? file.name : `${file.name}.pdf`;
+
+  const documentData = await putFileServerSide({
+    name: fileName,
+    type: 'application/pdf',
+    arrayBuffer: async () => Promise.resolve(normalized),
+  });
+
+  return await createDocumentData({
+    type: documentData.type,
+    data: documentData.data,
+  });
+};
+
 /**
  * Uploads a file to the appropriate storage location.
  */

packages/lib/utils/fields.ts

@@ -81,6 +81,10 @@ export const mapFieldToLegacyField = (
 };
 
 export const parseCheckboxCustomText = (customText: string): number[] => {
+  if (!customText) {
+    return [];
+  }
+
   return JSON.parse(customText);
 };
 

packages/prisma/package.json

@@ -21,14 +21,14 @@
     "seed": "tsx ./seed-database.ts"
   },
   "dependencies": {
-    "@prisma/client": "^6.8.2",
+    "@prisma/client": "^6.18.0",
     "kysely": "0.26.3",
-    "prisma": "^6.8.2",
+    "prisma": "^6.18.0",
     "prisma-extension-kysely": "^3.0.0",
     "prisma-kysely": "^1.8.0",
-    "prisma-json-types-generator": "^3.2.2",
+    "prisma-json-types-generator": "^3.6.2",
     "ts-pattern": "^5.0.6",
-    "zod-prisma-types": "3.2.4"
+    "zod-prisma-types": "3.3.5"
   },
   "devDependencies": {
     "dotenv": "^16.5.0",

packages/prisma/schema.prisma

@@ -134,8 +134,8 @@ model Passkey {
   createdAt            DateTime  @default(now())
   updatedAt            DateTime  @default(now())
   lastUsedAt           DateTime?
-  credentialId         Bytes
-  credentialPublicKey  Bytes
+  credentialId         Bytes /// @zod.custom.use(z.instanceof(Uint8Array))
+  credentialPublicKey  Bytes /// @zod.custom.use(z.instanceof(Uint8Array))
   counter              BigInt
   credentialDeviceType String
   credentialBackedUp   Boolean

packages/prisma/seed/initial-seed.ts

@@ -1,11 +1,22 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { formatAlignmentTestFields } from '@documenso/app-tests/constants/field-alignment-pdf';
+import { FIELD_META_TEST_FIELDS } from '@documenso/app-tests/constants/field-meta-pdf';
+import { isBase64Image } from '@documenso/lib/constants/signatures';
 import { incrementDocumentId } from '@documenso/lib/server-only/envelope/increment-id';
-import { prefixedId } from '@documenso/lib/universal/id';
+import { nanoid, prefixedId } from '@documenso/lib/universal/id';
 
 import { prisma } from '..';
-import { DocumentDataType, DocumentSource, EnvelopeType } from '../client';
+import {
+  DocumentDataType,
+  DocumentSource,
+  DocumentStatus,
+  EnvelopeType,
+  ReadStatus,
+  SendStatus,
+  SigningStatus,
+} from '../client';
 import { seedPendingDocument } from './documents';
 import { seedDirectTemplate, seedTemplate } from './templates';
 import { seedUser } from './users';
@@ -155,7 +166,6 @@ export const seedDatabase = async () => {
       userId: exampleUser.user.id,
       teamId: exampleUser.team.id,
     }),
-
     seedTemplate({
       title: 'Template 1',
       userId: adminUser.user.id,
@@ -166,5 +176,185 @@ export const seedDatabase = async () => {
       userId: adminUser.user.id,
       teamId: adminUser.team.id,
     }),
+    seedAlignmentTestDocument({
+      userId: exampleUser.user.id,
+      teamId: exampleUser.team.id,
+      recipientName: exampleUser.user.name || '',
+      recipientEmail: exampleUser.user.email,
+      insertFields: false,
+      status: DocumentStatus.DRAFT,
+    }),
+    seedAlignmentTestDocument({
+      userId: exampleUser.user.id,
+      teamId: exampleUser.team.id,
+      recipientName: exampleUser.user.name || '',
+      recipientEmail: exampleUser.user.email,
+      insertFields: true,
+      status: DocumentStatus.PENDING,
+    }),
+    seedAlignmentTestDocument({
+      userId: adminUser.user.id,
+      teamId: adminUser.team.id,
+      recipientName: adminUser.user.name || '',
+      recipientEmail: adminUser.user.email,
+      insertFields: false,
+      status: DocumentStatus.DRAFT,
+    }),
+    seedAlignmentTestDocument({
+      userId: adminUser.user.id,
+      teamId: adminUser.team.id,
+      recipientName: adminUser.user.name || '',
+      recipientEmail: adminUser.user.email,
+      insertFields: true,
+      status: DocumentStatus.PENDING,
+    }),
   ]);
 };
+
+export const seedAlignmentTestDocument = async ({
+  userId,
+  teamId,
+  recipientName,
+  recipientEmail,
+  insertFields,
+  status,
+}: {
+  userId: number;
+  teamId: number;
+  recipientName: string;
+  recipientEmail: string;
+  insertFields: boolean;
+  status: DocumentStatus;
+}) => {
+  const alignmentPdf = fs
+    .readFileSync(path.join(__dirname, '../../../assets/field-font-alignment.pdf'))
+    .toString('base64');
+
+  const fieldMetaPdf = fs
+    .readFileSync(path.join(__dirname, '../../../assets/field-meta.pdf'))
+    .toString('base64');
+
+  const alignmentDocumentData = await createDocumentData({ documentData: alignmentPdf });
+  const fieldMetaDocumentData = await createDocumentData({ documentData: fieldMetaPdf });
+
+  const documentId = await incrementDocumentId();
+
+  const documentMeta = await prisma.documentMeta.create({
+    data: {},
+  });
+
+  const createdEnvelope = await prisma.envelope.create({
+    data: {
+      id: prefixedId('envelope'),
+      secondaryId: documentId.formattedDocumentId,
+      internalVersion: 2,
+      type: EnvelopeType.DOCUMENT,
+      documentMetaId: documentMeta.id,
+      source: DocumentSource.DOCUMENT,
+      title: `Envelope Full Field Test`,
+      status,
+      envelopeItems: {
+        createMany: {
+          data: [
+            {
+              id: prefixedId('envelope_item'),
+              title: `alignment-pdf`,
+              documentDataId: alignmentDocumentData.id,
+              order: 1,
+            },
+            {
+              id: prefixedId('envelope_item'),
+              title: `field-meta-pdf`,
+              documentDataId: fieldMetaDocumentData.id,
+              order: 2,
+            },
+          ],
+        },
+      },
+      userId,
+      teamId,
+      recipients: {
+        create: {
+          name: recipientName,
+          email: recipientEmail,
+          token: nanoid(),
+          sendStatus: status === 'DRAFT' ? SendStatus.NOT_SENT : SendStatus.SENT,
+          signingStatus: status === 'COMPLETED' ? SigningStatus.SIGNED : SigningStatus.NOT_SIGNED,
+          readStatus: status !== 'DRAFT' ? ReadStatus.OPENED : ReadStatus.NOT_OPENED,
+        },
+      },
+    },
+    include: {
+      recipients: true,
+      envelopeItems: true,
+    },
+  });
+
+  const { id, recipients, envelopeItems } = createdEnvelope;
+
+  const recipientId = recipients[0].id;
+  const envelopeItemAlignmentItem = envelopeItems.find((item) => item.order === 1)?.id;
+  const envelopeItemFieldMetaItem = envelopeItems.find((item) => item.order === 2)?.id;
+
+  if (!envelopeItemAlignmentItem || !envelopeItemFieldMetaItem) {
+    throw new Error('Envelope item not found');
+  }
+
+  await Promise.all(
+    formatAlignmentTestFields.map(async (field) => {
+      await prisma.field.create({
+        data: {
+          ...field,
+          recipientId,
+          envelopeItemId: envelopeItemAlignmentItem,
+          envelopeId: id,
+          customText: insertFields ? field.customText : '',
+          inserted: insertFields,
+          signature: field.signature
+            ? {
+                create: {
+                  recipientId,
+                  signatureImageAsBase64: isBase64Image(field.signature) ? field.signature : null,
+                  typedSignature: isBase64Image(field.signature) ? null : field.signature,
+                },
+              }
+            : undefined,
+        },
+      });
+    }),
+  );
+
+  await Promise.all(
+    FIELD_META_TEST_FIELDS.map(async (field) => {
+      await prisma.field.create({
+        data: {
+          ...field,
+          recipientId,
+          envelopeItemId: envelopeItemFieldMetaItem,
+          envelopeId: id,
+          customText: insertFields ? field.customText : '',
+          inserted: insertFields,
+          signature: field.signature
+            ? {
+                create: {
+                  recipientId,
+                  signatureImageAsBase64: isBase64Image(field.signature) ? field.signature : null,
+                  typedSignature: isBase64Image(field.signature) ? null : field.signature,
+                },
+              }
+            : undefined,
+        },
+      });
+    }),
+  );
+
+  return await prisma.envelope.findFirstOrThrow({
+    where: {
+      id: createdEnvelope.id,
+    },
+    include: {
+      recipients: true,
+      envelopeItems: true,
+    },
+  });
+};

packages/trpc/client/index.ts

@@ -1,17 +1,23 @@
-import { createTRPCClient, httpBatchLink, httpLink, splitLink } from '@trpc/client';
-import SuperJSON from 'superjson';
+import {
+  createTRPCClient,
+  httpBatchLink,
+  httpLink,
+  isNonJsonSerializable,
+  splitLink,
+} from '@trpc/client';
 
 import { getBaseUrl } from '@documenso/lib/universal/get-base-url';
 
 import type { AppRouter } from '../server/router';
+import { dataTransformer } from '../utils/data-transformer';
 
 export const trpc = createTRPCClient<AppRouter>({
   links: [
     splitLink({
-      condition: (op) => op.context.skipBatch === true,
+      condition: (op) => op.context.skipBatch === true || isNonJsonSerializable(op.input),
       true: httpLink({
         url: `${getBaseUrl()}/api/trpc`,
-        transformer: SuperJSON,
+        transformer: dataTransformer,
         headers: (opts) => {
           if (typeof opts.op.context.teamId === 'string') {
             return {
@@ -24,7 +30,7 @@ export const trpc = createTRPCClient<AppRouter>({
       }),
       false: httpBatchLink({
         url: `${getBaseUrl()}/api/trpc`,
-        transformer: SuperJSON,
+        transformer: dataTransformer,
         headers: (opts) => {
           const operationWithTeamId = opts.opList.find(
             (op) => op.context.teamId && typeof op.context.teamId === 'string',

packages/trpc/package.json

@@ -12,15 +12,21 @@
   "dependencies": {
     "@documenso/lib": "*",
     "@documenso/prisma": "*",
-    "@tanstack/react-query": "5.59.15",
-    "@trpc/client": "11.0.0-rc.648",
-    "@trpc/react-query": "11.0.0-rc.648",
-    "@trpc/server": "11.0.0-rc.648",
-    "@ts-rest/core": "^3.30.5",
+    "@tanstack/react-query": "5.90.5",
+    "@trpc/client": "11.7.0",
+    "@trpc/react-query": "11.7.0",
+    "@trpc/server": "11.7.0",
+    "@ts-rest/core": "^3.52.0",
+    "formidable": "^3.5.4",
     "luxon": "^3.4.0",
-    "superjson": "^1.13.1",
-    "trpc-to-openapi": "2.0.4",
+    "superjson": "^2.2.5",
+    "trpc-to-openapi": "2.4.0",
     "ts-pattern": "^5.0.5",
-    "zod": "3.24.1"
+    "zod": "^3.25.76",
+    "zod-form-data": "^2.0.8",
+    "zod-openapi": "^4.2.4"
+  },
+  "devDependencies": {
+    "@types/formidable": "^3.4.6"
   }
 }

packages/trpc/react/index.tsx

@@ -1,13 +1,13 @@
 import { useMemo, useState } from 'react';
 
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { httpBatchLink, httpLink, splitLink } from '@trpc/client';
+import { httpBatchLink, httpLink, isNonJsonSerializable, splitLink } from '@trpc/client';
 import { createTRPCReact } from '@trpc/react-query';
-import SuperJSON from 'superjson';
 
 import { getBaseUrl } from '@documenso/lib/universal/get-base-url';
 
 import type { AppRouter } from '../server/router';
+import { dataTransformer } from '../utils/data-transformer';
 
 export { getQueryKey } from '@trpc/react-query';
 
@@ -44,16 +44,16 @@ export function TrpcProvider({ children, headers }: TrpcProviderProps) {
       trpc.createClient({
         links: [
           splitLink({
-            condition: (op) => op.context.skipBatch === true,
+            condition: (op) => op.context.skipBatch === true || isNonJsonSerializable(op.input),
             true: httpLink({
               url: `${getBaseUrl()}/api/trpc`,
               headers,
-              transformer: SuperJSON,
+              transformer: dataTransformer,
             }),
             false: httpBatchLink({
               url: `${getBaseUrl()}/api/trpc`,
               headers,
-              transformer: SuperJSON,
+              transformer: dataTransformer,
             }),
           }),
         ],

packages/trpc/server/document-router/create-document-formdata.ts

@@ -0,0 +1,136 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { getServerLimits } from '@documenso/ee/server-only/limits/server';
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { createEnvelope } from '@documenso/lib/server-only/envelope/create-envelope';
+import { putPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
+import { mapSecondaryIdToDocumentId } from '@documenso/lib/utils/envelope';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZCreateDocumentFormDataRequestSchema,
+  ZCreateDocumentFormDataResponseSchema,
+  createDocumentFormDataMeta,
+} from './create-document-formdata.types';
+
+/**
+ * Temporary endpoint for V2 Beta until we allow passthrough documents on create.
+ *
+ * @public
+ */
+export const createDocumentFormDataRoute = authenticatedProcedure
+  .meta(createDocumentFormDataMeta)
+  .input(ZCreateDocumentFormDataRequestSchema)
+  .output(ZCreateDocumentFormDataResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+
+    const { payload, file } = input;
+
+    const {
+      title,
+      externalId,
+      visibility,
+      globalAccessAuth,
+      globalActionAuth,
+      recipients,
+      meta,
+      folderId,
+      attachments,
+    } = payload;
+
+    const { remaining } = await getServerLimits({ userId: user.id, teamId });
+
+    if (remaining.documents <= 0) {
+      throw new AppError(AppErrorCode.LIMIT_EXCEEDED, {
+        message: 'You have reached your document limit for this month. Please upgrade your plan.',
+        statusCode: 400,
+      });
+    }
+
+    const documentData = await putPdfFileServerSide(file);
+
+    const createdEnvelope = await createEnvelope({
+      userId: ctx.user.id,
+      teamId,
+      normalizePdf: false, // Not normalizing because of presigned URL.
+      internalVersion: 1,
+      data: {
+        type: EnvelopeType.DOCUMENT,
+        title,
+        externalId,
+        visibility,
+        globalAccessAuth,
+        globalActionAuth,
+        recipients: (recipients || []).map((recipient) => ({
+          ...recipient,
+          fields: (recipient.fields || []).map((field) => ({
+            ...field,
+            page: field.pageNumber,
+            positionX: field.pageX,
+            positionY: field.pageY,
+            documentDataId: documentData.id,
+          })),
+        })),
+        folderId,
+        envelopeItems: [
+          {
+            // If you ever allow more than 1 in this endpoint, make sure to use `maximumEnvelopeItemCount` to limit it.
+            documentDataId: documentData.id,
+          },
+        ],
+      },
+      attachments,
+      meta: {
+        ...meta,
+        emailSettings: meta?.emailSettings ?? undefined,
+      },
+      requestMetadata: ctx.metadata,
+    });
+
+    const envelopeItems = await prisma.envelopeItem.findMany({
+      where: {
+        envelopeId: createdEnvelope.id,
+      },
+      include: {
+        documentData: true,
+      },
+    });
+
+    const legacyDocumentId = mapSecondaryIdToDocumentId(createdEnvelope.secondaryId);
+
+    const firstDocumentData = envelopeItems[0].documentData;
+
+    if (!firstDocumentData) {
+      throw new Error('Document data not found');
+    }
+
+    return {
+      document: {
+        ...createdEnvelope,
+        envelopeId: createdEnvelope.id,
+        documentDataId: firstDocumentData.id,
+        documentData: {
+          ...firstDocumentData,
+          envelopeItemId: envelopeItems[0].id,
+        },
+        documentMeta: {
+          ...createdEnvelope.documentMeta,
+          documentId: legacyDocumentId,
+        },
+        id: legacyDocumentId,
+        fields: createdEnvelope.fields.map((field) => ({
+          ...field,
+          documentId: legacyDocumentId,
+          templateId: null,
+        })),
+        recipients: createdEnvelope.recipients.map((recipient) => ({
+          ...recipient,
+          documentId: legacyDocumentId,
+          templateId: null,
+        })),
+      },
+      folder: createdEnvelope.folder, // Todo: Remove this prior to api-v2 release.
+    };
+  });

packages/trpc/server/document-router/create-document-formdata.types.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { zfd } from 'zod-form-data';
+
+import { ZDocumentSchema } from '@documenso/lib/types/document';
+import {
+  ZDocumentAccessAuthTypesSchema,
+  ZDocumentActionAuthTypesSchema,
+} from '@documenso/lib/types/document-auth';
+import { ZDocumentFormValuesSchema } from '@documenso/lib/types/document-form-values';
+import { ZDocumentMetaCreateSchema } from '@documenso/lib/types/document-meta';
+import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
+import {
+  ZFieldHeightSchema,
+  ZFieldPageNumberSchema,
+  ZFieldPageXSchema,
+  ZFieldPageYSchema,
+  ZFieldWidthSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+import { zodFormData } from '../../utils/zod-form-data';
+import { ZCreateRecipientSchema } from '../recipient-router/schema';
+import type { TrpcRouteMeta } from '../trpc';
+import {
+  ZDocumentExternalIdSchema,
+  ZDocumentTitleSchema,
+  ZDocumentVisibilitySchema,
+} from './schema';
+
+export const createDocumentFormDataMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/document/create/formdata',
+    contentTypes: ['multipart/form-data'],
+    summary: 'Create document',
+    description: 'Create a document using form data.',
+    tags: ['Document'],
+  },
+};
+
+const ZCreateDocumentFormDataPayloadRequestSchema = z.object({
+  title: ZDocumentTitleSchema,
+  externalId: ZDocumentExternalIdSchema.optional(),
+  visibility: ZDocumentVisibilitySchema.optional(),
+  globalAccessAuth: z.array(ZDocumentAccessAuthTypesSchema).optional(),
+  globalActionAuth: z.array(ZDocumentActionAuthTypesSchema).optional(),
+  formValues: ZDocumentFormValuesSchema.optional(),
+  folderId: z
+    .string()
+    .describe(
+      'The ID of the folder to create the document in. If not provided, the document will be created in the root folder.',
+    )
+    .optional(),
+  recipients: z
+    .array(
+      ZCreateRecipientSchema.extend({
+        fields: ZFieldAndMetaSchema.and(
+          z.object({
+            pageNumber: ZFieldPageNumberSchema,
+            pageX: ZFieldPageXSchema,
+            pageY: ZFieldPageYSchema,
+            width: ZFieldWidthSchema,
+            height: ZFieldHeightSchema,
+          }),
+        )
+          .array()
+          .optional(),
+      }),
+    )
+
+    .optional(),
+  attachments: z
+    .array(
+      z.object({
+        label: z.string().min(1, 'Label is required'),
+        data: z.string().url('Must be a valid URL'),
+        type: ZEnvelopeAttachmentTypeSchema.optional().default('link'),
+      }),
+    )
+    .optional(),
+  meta: ZDocumentMetaCreateSchema.optional(),
+});
+
+// !: Can't use zfd.formData() here because it receives `undefined`
+// !: somewhere in the pipeline of our openapi schema generation and throws
+// !: an error.
+export const ZCreateDocumentFormDataRequestSchema = zodFormData({
+  payload: zfd.json(ZCreateDocumentFormDataPayloadRequestSchema),
+  file: zfd.file(),
+});
+
+export const ZCreateDocumentFormDataResponseSchema = z.object({
+  document: ZDocumentSchema,
+});
+
+export type TCreateDocumentFormDataRequest = z.infer<typeof ZCreateDocumentFormDataRequestSchema>;
+export type TCreateDocumentFormDataResponse = z.infer<typeof ZCreateDocumentFormDataResponseSchema>;

packages/trpc/server/document-router/create-document.ts

@@ -3,6 +3,7 @@ import { EnvelopeType } from '@prisma/client';
 import { getServerLimits } from '@documenso/ee/server-only/limits/server';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { createEnvelope } from '@documenso/lib/server-only/envelope/create-envelope';
+import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
 import { mapSecondaryIdToDocumentId } from '@documenso/lib/utils/envelope';
 
 import { authenticatedProcedure } from '../trpc';
@@ -16,7 +17,12 @@ export const createDocumentRoute = authenticatedProcedure
   .output(ZCreateDocumentResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId } = ctx;
-    const { title, documentDataId, timezone, folderId, attachments } = input;
+
+    const { payload, file } = input;
+
+    const { title, timezone, folderId, attachments } = payload;
+
+    const { id: documentDataId } = await putNormalizedPdfFileServerSide(file);
 
     ctx.logger.info({
       input: {
@@ -55,6 +61,7 @@ export const createDocumentRoute = authenticatedProcedure
     });
 
     return {
+      envelopeId: document.id,
       legacyDocumentId: mapSecondaryIdToDocumentId(document.secondaryId),
     };
   });

packages/trpc/server/document-router/create-document.types.ts

@@ -1,23 +1,27 @@
 import { z } from 'zod';
+import { zfd } from 'zod-form-data';
 
 import { ZDocumentMetaTimezoneSchema } from '@documenso/lib/types/document-meta';
 import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
 
+import { zodFormData } from '../../utils/zod-form-data';
+import type { TrpcRouteMeta } from '../trpc';
 import { ZDocumentTitleSchema } from './schema';
 
 // Currently not in use until we allow passthrough documents on create.
-// export const createDocumentMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/document/create',
-//     summary: 'Create document',
-//     tags: ['Document'],
-//   },
-// };
+export const createDocumentMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/document/create',
+    contentTypes: ['multipart/form-data'],
+    summary: 'Create document',
+    description: 'Create a document using form data.',
+    tags: ['Document'],
+  },
+};
 
-export const ZCreateDocumentRequestSchema = z.object({
+export const ZCreateDocumentPayloadSchema = z.object({
   title: ZDocumentTitleSchema,
-  documentDataId: z.string().min(1),
   timezone: ZDocumentMetaTimezoneSchema.optional(),
   folderId: z.string().describe('The ID of the folder to create the document in').optional(),
   attachments: z
@@ -31,9 +35,16 @@ export const ZCreateDocumentRequestSchema = z.object({
     .optional(),
 });
 
+export const ZCreateDocumentRequestSchema = zodFormData({
+  payload: zfd.json(ZCreateDocumentPayloadSchema),
+  file: zfd.file(),
+});
+
 export const ZCreateDocumentResponseSchema = z.object({
+  envelopeId: z.string(),
   legacyDocumentId: z.number(),
 });
 
+export type TCreateDocumentPayloadSchema = z.infer<typeof ZCreateDocumentPayloadSchema>;
 export type TCreateDocumentRequest = z.infer<typeof ZCreateDocumentRequestSchema>;
 export type TCreateDocumentResponse = z.infer<typeof ZCreateDocumentResponseSchema>;

packages/trpc/server/document-router/router.ts

@@ -5,6 +5,7 @@ import { deleteAttachmentRoute } from './attachment/delete-attachment';
 import { findAttachmentsRoute } from './attachment/find-attachments';
 import { updateAttachmentRoute } from './attachment/update-attachment';
 import { createDocumentRoute } from './create-document';
+import { createDocumentFormDataRoute } from './create-document-formdata';
 import { createDocumentTemporaryRoute } from './create-document-temporary';
 import { deleteDocumentRoute } from './delete-document';
 import { distributeDocumentRoute } from './distribute-document';
@@ -40,6 +41,7 @@ export const documentRouter = router({
   // Temporary v2 beta routes to be removed once V2 is fully released.
   download: downloadDocumentRoute,
   createDocumentTemporary: createDocumentTemporaryRoute,
+  createDocumentFormData: createDocumentFormDataRoute,
 
   // Internal document routes for custom frontend requests.
   getDocumentByToken: getDocumentByTokenRoute,

packages/trpc/server/envelope-router/attachment/create-attachment.ts

@@ -13,7 +13,7 @@ export const createAttachmentRoute = authenticatedProcedure
       path: '/envelope/attachment/create',
       summary: 'Create attachment',
       description: 'Create a new attachment for an envelope',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZCreateAttachmentRequestSchema)

packages/trpc/server/envelope-router/attachment/delete-attachment.ts

@@ -13,7 +13,7 @@ export const deleteAttachmentRoute = authenticatedProcedure
       path: '/envelope/attachment/delete',
       summary: 'Delete attachment',
       description: 'Delete an attachment from an envelope',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZDeleteAttachmentRequestSchema)

packages/trpc/server/envelope-router/attachment/find-attachments.ts

@@ -2,20 +2,20 @@ import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { findAttachmentsByEnvelopeId } from '@documenso/lib/server-only/envelope-attachment/find-attachments-by-envelope-id';
 import { findAttachmentsByToken } from '@documenso/lib/server-only/envelope-attachment/find-attachments-by-token';
 
-import { procedure } from '../../trpc';
+import { maybeAuthenticatedProcedure } from '../../trpc';
 import {
   ZFindAttachmentsRequestSchema,
   ZFindAttachmentsResponseSchema,
 } from './find-attachments.types';
 
-export const findAttachmentsRoute = procedure
+export const findAttachmentsRoute = maybeAuthenticatedProcedure
   .meta({
     openapi: {
       method: 'GET',
       path: '/envelope/attachment',
       summary: 'Find attachments',
       description: 'Find all attachments for an envelope',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZFindAttachmentsRequestSchema)

packages/trpc/server/envelope-router/attachment/update-attachment.ts

@@ -13,7 +13,7 @@ export const updateAttachmentRoute = authenticatedProcedure
       path: '/envelope/attachment/update',
       summary: 'Update attachment',
       description: 'Update an existing attachment',
-      tags: ['Envelope'],
+      tags: ['Envelope Attachment'],
     },
   })
   .input(ZUpdateAttachmentRequestSchema)

packages/trpc/server/envelope-router/create-envelope-items.ts

@@ -13,11 +13,21 @@ import {
 } from './create-envelope-items.types';
 
 export const createEnvelopeItemsRoute = authenticatedProcedure
+  // Todo: Envelopes - Pending direct uploads
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/item/create-many',
+      summary: 'Create envelope items',
+      description: 'Create multiple envelope items for an envelope',
+      tags: ['Envelope Item'],
+    },
+  })
   .input(ZCreateEnvelopeItemsRequestSchema)
   .output(ZCreateEnvelopeItemsResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId, metadata } = ctx;
-    const { envelopeId, items } = input;
+    const { envelopeId, data: items } = input;
 
     ctx.logger.info({
       input: {

packages/trpc/server/envelope-router/create-envelope-items.types.ts

@@ -7,7 +7,7 @@ import { ZDocumentTitleSchema } from '../document-router/schema';
 
 export const ZCreateEnvelopeItemsRequestSchema = z.object({
   envelopeId: z.string(),
-  items: z
+  data: z
     .object({
       title: ZDocumentTitleSchema,
       documentDataId: z.string(),

packages/trpc/server/envelope-router/create-envelope.ts

@@ -1,6 +1,7 @@
 import { getServerLimits } from '@documenso/ee/server-only/limits/server';
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { createEnvelope } from '@documenso/lib/server-only/envelope/create-envelope';
+import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
 
 import { authenticatedProcedure } from '../trpc';
 import {
@@ -9,10 +10,22 @@ import {
 } from './create-envelope.types';
 
 export const createEnvelopeRoute = authenticatedProcedure
+  // Todo: Envelopes - Pending direct uploads
+  // .meta({
+  //   openapi: {
+  //     method: 'POST',
+  //     path: '/envelope/create',
+  //     summary: 'Create envelope',
+  //     tags: ['Envelope'],
+  //   },
+  // })
   .input(ZCreateEnvelopeRequestSchema)
   .output(ZCreateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId } = ctx;
+
+    const { payload, files } = input;
+
     const {
       title,
       type,
@@ -22,10 +35,9 @@ export const createEnvelopeRoute = authenticatedProcedure
       globalActionAuth,
       recipients,
       folderId,
-      items,
       meta,
       attachments,
-    } = input;
+    } = payload;
 
     ctx.logger.info({
       input: {
@@ -45,13 +57,62 @@ export const createEnvelopeRoute = authenticatedProcedure
       });
     }
 
-    if (items.length > maximumEnvelopeItemCount) {
+    if (files.length > maximumEnvelopeItemCount) {
       throw new AppError('ENVELOPE_ITEM_LIMIT_EXCEEDED', {
         message: `You cannot upload more than ${maximumEnvelopeItemCount} envelope items per envelope`,
         statusCode: 400,
       });
     }
 
+    // For each file, stream to s3 and create the document data.
+    const envelopeItems = await Promise.all(
+      files.map(async (file) => {
+        const { id: documentDataId } = await putNormalizedPdfFileServerSide(file);
+
+        return {
+          title: file.name,
+          documentDataId,
+        };
+      }),
+    );
+
+    const recipientsToCreate = recipients?.map((recipient) => ({
+      email: recipient.email,
+      name: recipient.name,
+      role: recipient.role,
+      signingOrder: recipient.signingOrder,
+      accessAuth: recipient.accessAuth,
+      actionAuth: recipient.actionAuth,
+      fields: recipient.fields?.map((field) => {
+        let documentDataId: string | undefined = undefined;
+
+        if (typeof field.identifier === 'string') {
+          documentDataId = envelopeItems.find(
+            (item) => item.title === field.identifier,
+          )?.documentDataId;
+        }
+
+        if (typeof field.identifier === 'number') {
+          documentDataId = envelopeItems.at(field.identifier)?.documentDataId;
+        }
+
+        if (field.identifier === undefined) {
+          documentDataId = envelopeItems[0]?.documentDataId;
+        }
+
+        if (!documentDataId) {
+          throw new AppError(AppErrorCode.NOT_FOUND, {
+            message: 'Document data not found',
+          });
+        }
+
+        return {
+          ...field,
+          documentDataId,
+        };
+      }),
+    }));
+
     const envelope = await createEnvelope({
       userId: user.id,
       teamId,
@@ -63,9 +124,9 @@ export const createEnvelopeRoute = authenticatedProcedure
         visibility,
         globalAccessAuth,
         globalActionAuth,
-        recipients,
+        recipients: recipientsToCreate,
         folderId,
-        envelopeItems: items,
+        envelopeItems,
       },
       attachments,
       meta,

packages/trpc/server/envelope-router/create-envelope.types.ts

@@ -1,5 +1,6 @@
 import { EnvelopeType } from '@prisma/client';
 import { z } from 'zod';
+import { zfd } from 'zod-form-data';
 
 import {
   ZDocumentAccessAuthTypesSchema,
@@ -17,24 +18,28 @@ import {
 } from '@documenso/lib/types/field';
 import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
 
+import { zodFormData } from '../../utils/zod-form-data';
 import {
   ZDocumentExternalIdSchema,
   ZDocumentTitleSchema,
   ZDocumentVisibilitySchema,
 } from '../document-router/schema';
 import { ZCreateRecipientSchema } from '../recipient-router/schema';
+import type { TrpcRouteMeta } from '../trpc';
 
 // Currently not in use until we allow passthrough documents on create.
-// export const createEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/create',
-//     summary: 'Create envelope',
-//     tags: ['Envelope'],
-//   },
-// };
+export const createEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/create',
+    contentTypes: ['multipart/form-data'],
+    summary: 'Create envelope',
+    description: 'Create a envelope using form data.',
+    tags: ['Envelope'],
+  },
+};
 
-export const ZCreateEnvelopeRequestSchema = z.object({
+export const ZCreateEnvelopePayloadSchema = z.object({
   title: ZDocumentTitleSchema,
   type: z.nativeEnum(EnvelopeType),
   externalId: ZDocumentExternalIdSchema.optional(),
@@ -42,12 +47,6 @@ export const ZCreateEnvelopeRequestSchema = z.object({
   globalAccessAuth: z.array(ZDocumentAccessAuthTypesSchema).optional(),
   globalActionAuth: z.array(ZDocumentActionAuthTypesSchema).optional(),
   formValues: ZDocumentFormValuesSchema.optional(),
-  items: z
-    .object({
-      title: ZDocumentTitleSchema.optional(),
-      documentDataId: z.string(),
-    })
-    .array(),
   folderId: z
     .string()
     .describe(
@@ -59,11 +58,12 @@ export const ZCreateEnvelopeRequestSchema = z.object({
       ZCreateRecipientSchema.extend({
         fields: ZFieldAndMetaSchema.and(
           z.object({
-            documentDataId: z
-              .string()
+            identifier: z
+              .union([z.string(), z.number()])
               .describe(
-                'The ID of the document data to create the field on. If empty, the first document data will be used.',
-              ),
+                'Either the filename or the index of the file that was uploaded to attach the field to.',
+              )
+              .optional(),
             page: ZFieldPageNumberSchema,
             positionX: ZFieldPageXSchema,
             positionY: ZFieldPageYSchema,
@@ -88,9 +88,15 @@ export const ZCreateEnvelopeRequestSchema = z.object({
     .optional(),
 });
 
+export const ZCreateEnvelopeRequestSchema = zodFormData({
+  payload: zfd.json(ZCreateEnvelopePayloadSchema),
+  files: zfd.repeatableOfType(zfd.file()),
+});
+
 export const ZCreateEnvelopeResponseSchema = z.object({
   id: z.string(),
 });
 
+export type TCreateEnvelopePayload = z.infer<typeof ZCreateEnvelopePayloadSchema>;
 export type TCreateEnvelopeRequest = z.infer<typeof ZCreateEnvelopeRequestSchema>;
 export type TCreateEnvelopeResponse = z.infer<typeof ZCreateEnvelopeResponseSchema>;

packages/trpc/server/envelope-router/delete-envelope-item.ts

@@ -12,6 +12,15 @@ import {
 } from './delete-envelope-item.types';
 
 export const deleteEnvelopeItemRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/item/delete',
+      summary: 'Delete envelope item',
+      description: 'Delete an envelope item from an envelope',
+      tags: ['Envelope Item'],
+    },
+  })
   .input(ZDeleteEnvelopeItemRequestSchema)
   .output(ZDeleteEnvelopeItemResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/delete-envelope.ts

@@ -1,8 +1,10 @@
 import { EnvelopeType } from '@prisma/client';
 import { match } from 'ts-pattern';
 
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { deleteDocument } from '@documenso/lib/server-only/document/delete-document';
 import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
+import { prisma } from '@documenso/prisma';
 
 import { authenticatedProcedure } from '../trpc';
 import {
@@ -11,12 +13,19 @@ import {
 } from './delete-envelope.types';
 
 export const deleteEnvelopeRoute = authenticatedProcedure
-  // .meta(deleteEnvelopeMeta)
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/delete',
+      summary: 'Delete envelope',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZDeleteEnvelopeRequestSchema)
   .output(ZDeleteEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { teamId } = ctx;
-    const { envelopeId, envelopeType } = input;
+    const { envelopeId } = input;
 
     ctx.logger.info({
       input: {
@@ -24,7 +33,22 @@ export const deleteEnvelopeRoute = authenticatedProcedure
       },
     });
 
-    await match(envelopeType)
+    const unsafeEnvelope = await prisma.envelope.findUnique({
+      where: {
+        id: envelopeId,
+      },
+      select: {
+        type: true,
+      },
+    });
+
+    if (!unsafeEnvelope) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Envelope not found',
+      });
+    }
+
+    await match(unsafeEnvelope.type)
       .with(EnvelopeType.DOCUMENT, async () =>
         deleteDocument({
           userId: ctx.user.id,

packages/trpc/server/envelope-router/delete-envelope.types.ts

@@ -1,18 +1,7 @@
-import { EnvelopeType } from '@prisma/client';
 import { z } from 'zod';
 
-// export const deleteEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/delete',
-//     summary: 'Delete envelope',
-//     tags: ['Envelope'],
-//   },
-// };
-
 export const ZDeleteEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),
-  envelopeType: z.nativeEnum(EnvelopeType),
 });
 
 export const ZDeleteEnvelopeResponseSchema = z.void();

packages/trpc/server/envelope-router/distribute-envelope.ts

@@ -8,7 +8,15 @@ import {
 } from './distribute-envelope.types';
 
 export const distributeEnvelopeRoute = authenticatedProcedure
-  // .meta(distributeEnvelopeMeta)
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/distribute',
+      summary: 'Distribute envelope',
+      description: 'Send the envelope to recipients based on your distribution method',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZDistributeEnvelopeRequestSchema)
   .output(ZDistributeEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/distribute-envelope.types.ts

@@ -2,16 +2,6 @@ import { z } from 'zod';
 
 import { ZDocumentMetaUpdateSchema } from '@documenso/lib/types/document-meta';
 
-// export const distributeEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/distribute',
-//     summary: 'Distribute envelope',
-//     description: 'Send the document out to recipients based on your distribution method',
-//     tags: ['Envelope'],
-//   },
-// };
-
 export const ZDistributeEnvelopeRequestSchema = z.object({
   envelopeId: z.string().describe('The ID of the envelope to send.'),
   meta: ZDocumentMetaUpdateSchema.pick({

packages/trpc/server/envelope-router/duplicate-envelope.ts

@@ -7,6 +7,15 @@ import {
 } from './duplicate-envelope.types';
 
 export const duplicateEnvelopeRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/duplicate',
+      summary: 'Duplicate envelope',
+      description: 'Duplicate an envelope with all its settings',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZDuplicateEnvelopeRequestSchema)
   .output(ZDuplicateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.ts

@@ -0,0 +1,41 @@
+import { createEnvelopeFields } from '@documenso/lib/server-only/field/create-envelope-fields';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZCreateEnvelopeFieldsRequestSchema,
+  ZCreateEnvelopeFieldsResponseSchema,
+} from './create-envelope-fields.types';
+
+export const createEnvelopeFieldsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/field/create-many',
+      summary: 'Create envelope fields',
+      description: 'Create multiple fields for an envelope',
+      tags: ['Envelope Fields'],
+    },
+  })
+  .input(ZCreateEnvelopeFieldsRequestSchema)
+  .output(ZCreateEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { envelopeId, data: fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await createEnvelopeFields({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      fields,
+      requestMetadata: metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.types.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+const ZCreateFieldSchema = ZFieldAndMetaSchema.and(
+  z.object({
+    recipientId: z.number().describe('The ID of the recipient to create the field for'),
+    envelopeItemId: z
+      .string()
+      .optional()
+      .describe(
+        'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
+      ),
+    page: ZFieldPageNumberSchema,
+    positionX: ZClampedFieldPositionXSchema,
+    positionY: ZClampedFieldPositionYSchema,
+    width: ZClampedFieldWidthSchema,
+    height: ZClampedFieldHeightSchema,
+  }),
+);
+
+export const ZCreateEnvelopeFieldsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZCreateFieldSchema.array(),
+});
+
+export const ZCreateEnvelopeFieldsResponseSchema = z.object({
+  fields: z.array(ZFieldSchema),
+});
+
+export type TCreateEnvelopeFieldsRequest = z.infer<typeof ZCreateEnvelopeFieldsRequestSchema>;
+export type TCreateEnvelopeFieldsResponse = z.infer<typeof ZCreateEnvelopeFieldsResponseSchema>;

packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.ts

@@ -0,0 +1,125 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
+import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
+import { canRecipientFieldsBeModified } from '@documenso/lib/utils/recipients';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeFieldRequestSchema,
+  ZDeleteEnvelopeFieldResponseSchema,
+} from './delete-envelope-field.types';
+
+export const deleteEnvelopeFieldRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/field/delete',
+      summary: 'Delete envelope field',
+      description: 'Delete an envelope field',
+      tags: ['Envelope Field'],
+    },
+  })
+  .input(ZDeleteEnvelopeFieldRequestSchema)
+  .output(ZDeleteEnvelopeFieldResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { fieldId } = input;
+
+    ctx.logger.info({
+      input: {
+        fieldId,
+      },
+    });
+
+    const unsafeField = await prisma.field.findUnique({
+      where: {
+        id: fieldId,
+      },
+      select: {
+        envelopeId: true,
+      },
+    });
+
+    if (!unsafeField) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Field not found',
+      });
+    }
+
+    const { envelopeWhereInput } = await getEnvelopeWhereInput({
+      id: {
+        type: 'envelopeId',
+        id: unsafeField.envelopeId,
+      },
+      type: null,
+      userId: user.id,
+      teamId,
+    });
+
+    const envelope = await prisma.envelope.findUnique({
+      where: envelopeWhereInput,
+      include: {
+        recipients: {
+          include: {
+            fields: true,
+          },
+        },
+      },
+    });
+
+    const recipientWithFields = envelope?.recipients.find((recipient) =>
+      recipient.fields.some((field) => field.id === fieldId),
+    );
+    const fieldToDelete = recipientWithFields?.fields.find((field) => field.id === fieldId);
+
+    if (!envelope || !recipientWithFields || !fieldToDelete) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Field not found',
+      });
+    }
+
+    if (envelope.completedAt) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope already complete',
+      });
+    }
+
+    // Check whether the recipient associated with the field can have new fields created.
+    if (!canRecipientFieldsBeModified(recipientWithFields, recipientWithFields.fields)) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Recipient has already interacted with the document.',
+      });
+    }
+
+    await prisma.$transaction(async (tx) => {
+      const deletedField = await tx.field.delete({
+        where: {
+          id: fieldToDelete.id,
+          envelopeId: envelope.id,
+        },
+      });
+
+      // Handle field deleted audit log.
+      if (envelope.type === EnvelopeType.DOCUMENT) {
+        await tx.documentAuditLog.create({
+          data: createDocumentAuditLogData({
+            type: DOCUMENT_AUDIT_LOG_TYPE.FIELD_DELETED,
+            envelopeId: envelope.id,
+            metadata,
+            data: {
+              fieldId: deletedField.secondaryId,
+              fieldRecipientEmail: recipientWithFields.email,
+              fieldRecipientId: deletedField.recipientId,
+              fieldType: deletedField.type,
+            },
+          }),
+        });
+      }
+
+      return deletedField;
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.types.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const ZDeleteEnvelopeFieldRequestSchema = z.object({
+  fieldId: z.number(),
+});
+
+export const ZDeleteEnvelopeFieldResponseSchema = z.void();
+
+export type TDeleteEnvelopeFieldRequest = z.infer<typeof ZDeleteEnvelopeFieldRequestSchema>;
+export type TDeleteEnvelopeFieldResponse = z.infer<typeof ZDeleteEnvelopeFieldResponseSchema>;

packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.ts

@@ -0,0 +1,36 @@
+import { getFieldById } from '@documenso/lib/server-only/field/get-field-by-id';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZGetEnvelopeFieldRequestSchema,
+  ZGetEnvelopeFieldResponseSchema,
+} from './get-envelope-field.types';
+
+export const getEnvelopeFieldRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'GET',
+      path: '/envelope/field/{fieldId}',
+      summary: 'Get envelope field',
+      description: 'Returns an envelope field given an ID',
+      tags: ['Envelope Field'],
+    },
+  })
+  .input(ZGetEnvelopeFieldRequestSchema)
+  .output(ZGetEnvelopeFieldResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { fieldId } = input;
+
+    ctx.logger.info({
+      input: {
+        fieldId,
+      },
+    });
+
+    return await getFieldById({
+      userId: user.id,
+      teamId,
+      fieldId,
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+import { ZEnvelopeFieldSchema } from '@documenso/lib/types/field';
+
+export const ZGetEnvelopeFieldRequestSchema = z.object({
+  fieldId: z.number(),
+});
+
+export const ZGetEnvelopeFieldResponseSchema = ZEnvelopeFieldSchema;
+
+export type TGetEnvelopeFieldRequest = z.infer<typeof ZGetEnvelopeFieldRequestSchema>;
+export type TGetEnvelopeFieldResponse = z.infer<typeof ZGetEnvelopeFieldResponseSchema>;

packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.ts

@@ -0,0 +1,42 @@
+import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZUpdateEnvelopeFieldsRequestSchema,
+  ZUpdateEnvelopeFieldsResponseSchema,
+} from './update-envelope-fields.types';
+
+export const updateEnvelopeFieldsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/field/update-many',
+      summary: 'Update envelope fields',
+      description: 'Update multiple envelope fields for an envelope',
+      tags: ['Envelope Field'],
+    },
+  })
+  .input(ZUpdateEnvelopeFieldsRequestSchema)
+  .output(ZUpdateEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data: fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await updateEnvelopeFields({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+      fields,
+      requestMetadata: ctx.metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.types.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+const ZUpdateFieldSchema = ZFieldAndMetaSchema.and(
+  z.object({
+    id: z.number().describe('The ID of the field to update.'),
+    envelopeItemId: z
+      .string()
+      .optional()
+      .describe(
+        'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
+      ),
+    page: ZFieldPageNumberSchema.optional(),
+    positionX: ZClampedFieldPositionXSchema.optional(),
+    positionY: ZClampedFieldPositionYSchema.optional(),
+    width: ZClampedFieldWidthSchema.optional(),
+    height: ZClampedFieldHeightSchema.optional(),
+  }),
+);
+
+export const ZUpdateEnvelopeFieldsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZUpdateFieldSchema.array(),
+});
+
+export const ZUpdateEnvelopeFieldsResponseSchema = z.object({
+  fields: z.array(ZFieldSchema),
+});
+
+export type TUpdateEnvelopeFieldsRequest = z.infer<typeof ZUpdateEnvelopeFieldsRequestSchema>;
+export type TUpdateEnvelopeFieldsResponse = z.infer<typeof ZUpdateEnvelopeFieldsResponseSchema>;

packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.ts

@@ -0,0 +1,41 @@
+import { createEnvelopeRecipients } from '@documenso/lib/server-only/recipient/create-envelope-recipients';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZCreateEnvelopeRecipientsRequestSchema,
+  ZCreateEnvelopeRecipientsResponseSchema,
+} from './create-envelope-recipients.types';
+
+export const createEnvelopeRecipientsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/recipient/create-many',
+      summary: 'Create envelope recipients',
+      description: 'Create multiple recipients for an envelope',
+      tags: ['Envelope Recipients'],
+    },
+  })
+  .input(ZCreateEnvelopeRecipientsRequestSchema)
+  .output(ZCreateEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { envelopeId, data: recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await createEnvelopeRecipients({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.types.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+import { ZEnvelopeRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+import { ZCreateRecipientSchema } from '../../recipient-router/schema';
+
+export const ZCreateEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZCreateRecipientSchema.array(),
+});
+
+export const ZCreateEnvelopeRecipientsResponseSchema = z.object({
+  recipients: ZEnvelopeRecipientLiteSchema.array(),
+});
+
+export type TCreateEnvelopeRecipientsRequest = z.infer<
+  typeof ZCreateEnvelopeRecipientsRequestSchema
+>;
+export type TCreateEnvelopeRecipientsResponse = z.infer<
+  typeof ZCreateEnvelopeRecipientsResponseSchema
+>;

packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.ts

@@ -0,0 +1,37 @@
+import { deleteEnvelopeRecipient } from '@documenso/lib/server-only/recipient/delete-envelope-recipient';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeRecipientRequestSchema,
+  ZDeleteEnvelopeRecipientResponseSchema,
+} from './delete-envelope-recipient.types';
+
+export const deleteEnvelopeRecipientRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/recipient/delete',
+      summary: 'Delete envelope recipient',
+      description: 'Delete an envelope recipient',
+      tags: ['Envelope Recipient'],
+    },
+  })
+  .input(ZDeleteEnvelopeRecipientRequestSchema)
+  .output(ZDeleteEnvelopeRecipientResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { recipientId } = input;
+
+    ctx.logger.info({
+      input: {
+        recipientId,
+      },
+    });
+
+    await deleteEnvelopeRecipient({
+      userId: user.id,
+      teamId,
+      recipientId,
+      requestMetadata: metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const ZDeleteEnvelopeRecipientRequestSchema = z.object({
+  recipientId: z.number(),
+});
+
+export const ZDeleteEnvelopeRecipientResponseSchema = z.void();
+
+export type TDeleteEnvelopeRecipientRequest = z.infer<typeof ZDeleteEnvelopeRecipientRequestSchema>;
+export type TDeleteEnvelopeRecipientResponse = z.infer<
+  typeof ZDeleteEnvelopeRecipientResponseSchema
+>;

packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.ts

@@ -0,0 +1,52 @@
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZGetEnvelopeRecipientRequestSchema,
+  ZGetEnvelopeRecipientResponseSchema,
+} from './get-envelope-recipient.types';
+
+export const getEnvelopeRecipientRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'GET',
+      path: '/envelope/recipient/{recipientId}',
+      summary: 'Get envelope recipient',
+      description: 'Returns an envelope recipient given an ID',
+      tags: ['Envelope Recipient'],
+    },
+  })
+  .input(ZGetEnvelopeRecipientRequestSchema)
+  .output(ZGetEnvelopeRecipientResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { recipientId } = input;
+
+    ctx.logger.info({
+      input: {
+        recipientId,
+      },
+    });
+
+    const recipient = await prisma.recipient.findFirst({
+      where: {
+        id: recipientId,
+        envelope: {
+          team: buildTeamWhereQuery({ teamId, userId: user.id }),
+        },
+      },
+      include: {
+        fields: true,
+      },
+    });
+
+    if (!recipient) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Recipient not found',
+      });
+    }
+
+    return recipient;
+  });

packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.types.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+import { ZEnvelopeRecipientSchema } from '@documenso/lib/types/recipient';
+
+export const ZGetEnvelopeRecipientRequestSchema = z.object({
+  recipientId: z.number(),
+});
+
+export const ZGetEnvelopeRecipientResponseSchema = ZEnvelopeRecipientSchema;
+
+export type TGetEnvelopeRecipientRequest = z.infer<typeof ZGetEnvelopeRecipientRequestSchema>;
+export type TGetEnvelopeRecipientResponse = z.infer<typeof ZGetEnvelopeRecipientResponseSchema>;

packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.ts

@@ -0,0 +1,41 @@
+import { updateEnvelopeRecipients } from '@documenso/lib/server-only/recipient/update-envelope-recipients';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZUpdateEnvelopeRecipientsRequestSchema,
+  ZUpdateEnvelopeRecipientsResponseSchema,
+} from './update-envelope-recipients.types';
+
+export const updateEnvelopeRecipientsRoute = authenticatedProcedure
+  .meta({
+    openapi: {
+      method: 'POST',
+      path: '/envelope/recipient/update-many',
+      summary: 'Update envelope recipients',
+      description: 'Update multiple recipients for an envelope',
+      tags: ['Envelope Recipient'],
+    },
+  })
+  .input(ZUpdateEnvelopeRecipientsRequestSchema)
+  .output(ZUpdateEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data: recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await updateEnvelopeRecipients({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: ctx.metadata,
+    });
+  });

packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.types.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+import { ZUpdateRecipientSchema } from '../../recipient-router/schema';
+
+export const ZUpdateEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZUpdateRecipientSchema.array(),
+});
+
+export const ZUpdateEnvelopeRecipientsResponseSchema = z.object({
+  recipients: ZRecipientLiteSchema.array(),
+});
+
+export type TUpdateEnvelopeRecipientsRequest = z.infer<
+  typeof ZUpdateEnvelopeRecipientsRequestSchema
+>;
+export type TUpdateEnvelopeRecipientsResponse = z.infer<
+  typeof ZUpdateEnvelopeRecipientsResponseSchema
+>;

packages/trpc/server/envelope-router/get-envelope.ts

@@ -4,7 +4,15 @@ import { authenticatedProcedure } from '../trpc';
 import { ZGetEnvelopeRequestSchema, ZGetEnvelopeResponseSchema } from './get-envelope.types';
 
 export const getEnvelopeRoute = authenticatedProcedure
-  // .meta(getEnvelopeMeta)
+  .meta({
+    openapi: {
+      method: 'GET',
+      path: '/envelope/{envelopeId}',
+      summary: 'Get envelope',
+      description: 'Returns an envelope given an ID',
+      tags: ['Envelope'],
+    },
+  })
   .input(ZGetEnvelopeRequestSchema)
   .output(ZGetEnvelopeResponseSchema)
   .query(async ({ input, ctx }) => {

packages/trpc/server/envelope-router/get-envelope.types.ts

@@ -2,16 +2,6 @@ import { z } from 'zod';
 
 import { ZEnvelopeSchema } from '@documenso/lib/types/envelope';
 
-// export const getEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'GET',
-//     path: '/envelope/{envelopeId}',
-//     summary: 'Get envelope',
-//     description: 'Returns a envelope given an ID',
-//     tags: ['Envelope'],
-//   },
-// };
-
 export const ZGetEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),
 });