Merge branch 'main' into feat/unlink-documents-deleted-org

packages/trpc/server/admin-router/get-admin-organisation.ts

@@ -39,6 +39,11 @@ export const getAdminOrganisation = async ({ organisationId }: GetOrganisationOp
       teams: true,
       members: {
         include: {
+          organisationGroupMembers: {
+            include: {
+              group: true,
+            },
+          },
           user: {
             select: {
               id: true,

packages/trpc/server/admin-router/get-admin-organisation.types.ts

@@ -3,6 +3,8 @@ import { z } from 'zod';
 import { ZOrganisationSchema } from '@documenso/lib/types/organisation';
 import OrganisationClaimSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationClaimSchema';
 import OrganisationGlobalSettingsSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGlobalSettingsSchema';
+import OrganisationGroupMemberSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGroupMemberSchema';
+import OrganisationGroupSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGroupSchema';
 import OrganisationMemberSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationMemberSchema';
 import SubscriptionSchema from '@documenso/prisma/generated/zod/modelSchema/SubscriptionSchema';
 import TeamSchema from '@documenso/prisma/generated/zod/modelSchema/TeamSchema';
@@ -30,6 +32,18 @@ export const ZGetAdminOrganisationResponseSchema = ZOrganisationSchema.extend({
       email: true,
       name: true,
     }),
+    organisationGroupMembers: z.array(
+      OrganisationGroupMemberSchema.pick({
+        id: true,
+        groupId: true,
+      }).extend({
+        group: OrganisationGroupSchema.pick({
+          id: true,
+          type: true,
+          organisationRole: true,
+        }),
+      }),
+    ),
   }).array(),
   subscription: SubscriptionSchema.nullable(),
   organisationClaim: OrganisationClaimSchema,

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

@@ -17,6 +17,7 @@ import { promoteMemberToOwnerRoute } from './promote-member-to-owner';
 import { resealDocumentRoute } from './reseal-document';
 import { resetTwoFactorRoute } from './reset-two-factor-authentication';
 import { updateAdminOrganisationRoute } from './update-admin-organisation';
+import { updateOrganisationMemberRoleRoute } from './update-organisation-member-role';
 import { updateRecipientRoute } from './update-recipient';
 import { updateSiteSettingRoute } from './update-site-setting';
 import { updateSubscriptionClaimRoute } from './update-subscription-claim';
@@ -31,6 +32,7 @@ export const adminRouter = router({
   },
   organisationMember: {
     promoteToOwner: promoteMemberToOwnerRoute,
+    updateRole: updateOrganisationMemberRoleRoute,
   },
   claims: {
     find: findSubscriptionClaimsRoute,

packages/trpc/server/admin-router/update-organisation-member-role.ts

@@ -0,0 +1,220 @@
+import { OrganisationGroupType, OrganisationMemberRole } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { generateDatabaseId } from '@documenso/lib/universal/id';
+import { getHighestOrganisationRoleInGroup } from '@documenso/lib/utils/organisations';
+import { prisma } from '@documenso/prisma';
+
+import { adminProcedure } from '../trpc';
+import {
+  ZUpdateOrganisationMemberRoleRequestSchema,
+  ZUpdateOrganisationMemberRoleResponseSchema,
+} from './update-organisation-member-role.types';
+
+/**
+ * Admin mutation to update organisation member role or transfer ownership.
+ *
+ * This mutation handles two scenarios:
+ * 1. When role='OWNER': Transfers organisation ownership and promotes to ADMIN
+ * 2. When role=ADMIN/MANAGER/MEMBER: Updates group membership
+ *
+ * Admin privileges bypass normal hierarchy restrictions.
+ */
+export const updateOrganisationMemberRoleRoute = adminProcedure
+  .input(ZUpdateOrganisationMemberRoleRequestSchema)
+  .output(ZUpdateOrganisationMemberRoleResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { organisationId, userId, role } = input;
+
+    ctx.logger.info({
+      input: {
+        organisationId,
+        userId,
+        role,
+      },
+    });
+
+    const organisation = await prisma.organisation.findUnique({
+      where: {
+        id: organisationId,
+      },
+      include: {
+        groups: {
+          where: {
+            type: OrganisationGroupType.INTERNAL_ORGANISATION,
+          },
+        },
+        members: {
+          where: {
+            userId,
+          },
+          include: {
+            organisationGroupMembers: {
+              include: {
+                group: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!organisation) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Organisation not found',
+      });
+    }
+
+    const [member] = organisation.members;
+
+    if (!member) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'User is not a member of this organisation',
+      });
+    }
+
+    const currentOrganisationRole = getHighestOrganisationRoleInGroup(
+      member.organisationGroupMembers.flatMap((member) => member.group),
+    );
+
+    if (role === 'OWNER') {
+      if (organisation.ownerUserId === userId) {
+        throw new AppError(AppErrorCode.INVALID_REQUEST, {
+          message: 'User is already the owner of this organisation',
+        });
+      }
+
+      const currentMemberGroup = organisation.groups.find(
+        (group) => group.organisationRole === currentOrganisationRole,
+      );
+
+      const adminGroup = organisation.groups.find(
+        (group) => group.organisationRole === OrganisationMemberRole.ADMIN,
+      );
+
+      if (!currentMemberGroup) {
+        ctx.logger.error({
+          message: '[CRITICAL]: Missing internal group',
+          organisationId,
+          userId,
+          role: currentOrganisationRole,
+        });
+
+        throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+          message: 'Current member group not found',
+        });
+      }
+
+      if (!adminGroup) {
+        ctx.logger.error({
+          message: '[CRITICAL]: Missing internal group',
+          organisationId,
+          userId,
+          targetRole: 'ADMIN',
+        });
+
+        throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+          message: 'Admin group not found',
+        });
+      }
+
+      await prisma.$transaction(async (tx) => {
+        await tx.organisation.update({
+          where: {
+            id: organisationId,
+          },
+          data: {
+            ownerUserId: userId,
+          },
+        });
+
+        if (currentOrganisationRole !== OrganisationMemberRole.ADMIN) {
+          await tx.organisationGroupMember.delete({
+            where: {
+              organisationMemberId_groupId: {
+                organisationMemberId: member.id,
+                groupId: currentMemberGroup.id,
+              },
+            },
+          });
+
+          await tx.organisationGroupMember.create({
+            data: {
+              id: generateDatabaseId('group_member'),
+              organisationMemberId: member.id,
+              groupId: adminGroup.id,
+            },
+          });
+        }
+      });
+
+      return;
+    }
+
+    const targetRole = role as OrganisationMemberRole;
+
+    if (currentOrganisationRole === targetRole) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'User already has this role',
+      });
+    }
+
+    if (userId === organisation.ownerUserId && targetRole !== OrganisationMemberRole.ADMIN) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Organisation owner must be an admin. Transfer ownership first.',
+      });
+    }
+
+    const currentMemberGroup = organisation.groups.find(
+      (group) => group.organisationRole === currentOrganisationRole,
+    );
+
+    const newMemberGroup = organisation.groups.find(
+      (group) => group.organisationRole === targetRole,
+    );
+
+    if (!currentMemberGroup) {
+      ctx.logger.error({
+        message: '[CRITICAL]: Missing internal group',
+        organisationId,
+        userId,
+        role: currentOrganisationRole,
+      });
+
+      throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+        message: 'Current member group not found',
+      });
+    }
+
+    if (!newMemberGroup) {
+      ctx.logger.error({
+        message: '[CRITICAL]: Missing internal group',
+        organisationId,
+        userId,
+        targetRole,
+      });
+
+      throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+        message: 'New member group not found',
+      });
+    }
+
+    await prisma.$transaction(async (tx) => {
+      await tx.organisationGroupMember.delete({
+        where: {
+          organisationMemberId_groupId: {
+            organisationMemberId: member.id,
+            groupId: currentMemberGroup.id,
+          },
+        },
+      });
+
+      await tx.organisationGroupMember.create({
+        data: {
+          id: generateDatabaseId('group_member'),
+          organisationMemberId: member.id,
+          groupId: newMemberGroup.id,
+        },
+      });
+    });
+  });

packages/trpc/server/admin-router/update-organisation-member-role.types.ts

@@ -0,0 +1,30 @@
+import { OrganisationMemberRole } from '@prisma/client';
+import { z } from 'zod';
+
+/**
+ * Admin-only role selection that includes OWNER as a special case.
+ * OWNER is not a database role but triggers ownership transfer.
+ */
+export const ZAdminRoleSelection = z.enum([
+  'OWNER',
+  OrganisationMemberRole.ADMIN,
+  OrganisationMemberRole.MANAGER,
+  OrganisationMemberRole.MEMBER,
+]);
+
+export type TAdminRoleSelection = z.infer<typeof ZAdminRoleSelection>;
+
+export const ZUpdateOrganisationMemberRoleRequestSchema = z.object({
+  organisationId: z.string().min(1),
+  userId: z.number().min(1),
+  role: ZAdminRoleSelection,
+});
+
+export const ZUpdateOrganisationMemberRoleResponseSchema = z.void();
+
+export type TUpdateOrganisationMemberRoleRequest = z.infer<
+  typeof ZUpdateOrganisationMemberRoleRequestSchema
+>;
+export type TUpdateOrganisationMemberRoleResponse = z.infer<
+  typeof ZUpdateOrganisationMemberRoleResponseSchema
+>;

packages/trpc/server/context.ts

@@ -24,6 +24,7 @@ export const createTrpcContext = async ({
   const { session, user } = await getOptionalSession(c);
 
   const req = c.req.raw;
+  const res = c.res;
 
   const requestMetadata = c.get('context').requestMetadata;
 
@@ -54,6 +55,7 @@ export const createTrpcContext = async ({
       user: null,
       teamId,
       req,
+      res,
       metadata,
     };
   }
@@ -64,6 +66,7 @@ export const createTrpcContext = async ({
     user,
     teamId,
     req,
+    res,
     metadata,
   };
 };
@@ -80,6 +83,7 @@ export type TrpcContext = (
 ) & {
   teamId: number | undefined;
   req: Request;
+  res: Response;
   metadata: ApiRequestMetadata;
   logger: Logger;
 };

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

@@ -41,10 +41,14 @@ export const createAttachmentRoute = authenticatedProcedure
       type: EnvelopeType.DOCUMENT,
     });
 
-    await createAttachment({
+    const attachment = await createAttachment({
       envelopeId: envelope.id,
       teamId,
       userId,
       data,
     });
+
+    return {
+      id: attachment.id,
+    };
   });

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

@@ -8,7 +8,9 @@ export const ZCreateAttachmentRequestSchema = z.object({
   }),
 });
 
-export const ZCreateAttachmentResponseSchema = z.void();
+export const ZCreateAttachmentResponseSchema = z.object({
+  id: z.string(),
+});
 
 export type TCreateAttachmentRequest = z.infer<typeof ZCreateAttachmentRequestSchema>;
 export type TCreateAttachmentResponse = z.infer<typeof ZCreateAttachmentResponseSchema>;

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

@@ -1,5 +1,6 @@
 import { deleteAttachment } from '@documenso/lib/server-only/envelope-attachment/delete-attachment';
 
+import { ZGenericSuccessResponse } from '../../schema';
 import { authenticatedProcedure } from '../../trpc';
 import {
   ZDeleteAttachmentRequestSchema,
@@ -33,4 +34,6 @@ export const deleteAttachmentRoute = authenticatedProcedure
       userId,
       teamId,
     });
+
+    return ZGenericSuccessResponse;
   });

packages/trpc/server/document-router/attachment/delete-attachment.types.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../../schema';
+
 export const ZDeleteAttachmentRequestSchema = z.object({
   id: z.string(),
 });
 
-export const ZDeleteAttachmentResponseSchema = z.void();
+export const ZDeleteAttachmentResponseSchema = ZSuccessResponseSchema;
 
 export type TDeleteAttachmentRequest = z.infer<typeof ZDeleteAttachmentRequestSchema>;
 export type TDeleteAttachmentResponse = z.infer<typeof ZDeleteAttachmentResponseSchema>;

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

@@ -1,5 +1,6 @@
 import { updateAttachment } from '@documenso/lib/server-only/envelope-attachment/update-attachment';
 
+import { ZGenericSuccessResponse } from '../../schema';
 import { authenticatedProcedure } from '../../trpc';
 import {
   ZUpdateAttachmentRequestSchema,
@@ -34,4 +35,6 @@ export const updateAttachmentRoute = authenticatedProcedure
       teamId,
       data,
     });
+
+    return ZGenericSuccessResponse;
   });

packages/trpc/server/document-router/attachment/update-attachment.types.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../../schema';
+
 export const ZUpdateAttachmentRequestSchema = z.object({
   id: z.string(),
   data: z.object({
@@ -8,7 +10,7 @@ export const ZUpdateAttachmentRequestSchema = z.object({
   }),
 });
 
-export const ZUpdateAttachmentResponseSchema = z.void();
+export const ZUpdateAttachmentResponseSchema = ZSuccessResponseSchema;
 
 export type TUpdateAttachmentRequest = z.infer<typeof ZUpdateAttachmentRequestSchema>;
 export type TUpdateAttachmentResponse = z.infer<typeof ZUpdateAttachmentResponseSchema>;

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

@@ -3,20 +3,54 @@ 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 { insertFormValuesInPdf } from '@documenso/lib/server-only/pdf/insert-form-values-in-pdf';
+import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
 import { mapSecondaryIdToDocumentId } from '@documenso/lib/utils/envelope';
 
 import { authenticatedProcedure } from '../trpc';
 import {
   ZCreateDocumentRequestSchema,
   ZCreateDocumentResponseSchema,
+  createDocumentMeta,
 } from './create-document.types';
 
 export const createDocumentRoute = authenticatedProcedure
-  .input(ZCreateDocumentRequestSchema) // Note: Before releasing this to public, update the response schema to be correct.
+  .meta(createDocumentMeta)
+  .input(ZCreateDocumentRequestSchema)
   .output(ZCreateDocumentResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId } = ctx;
-    const { title, documentDataId, timezone, folderId, attachments } = input;
+
+    const { payload, file } = input;
+
+    const {
+      title,
+      externalId,
+      visibility,
+      globalAccessAuth,
+      globalActionAuth,
+      recipients,
+      meta,
+      folderId,
+      formValues,
+      attachments,
+    } = payload;
+
+    let pdf = Buffer.from(await file.arrayBuffer());
+
+    if (formValues) {
+      // eslint-disable-next-line require-atomic-updates
+      pdf = await insertFormValuesInPdf({
+        pdf,
+        formValues,
+      });
+    }
+
+    const { id: documentDataId } = await putNormalizedPdfFileServerSide({
+      name: file.name,
+      type: 'application/pdf',
+      arrayBuffer: async () => Promise.resolve(pdf),
+    });
 
     ctx.logger.info({
       input: {
@@ -40,7 +74,20 @@ export const createDocumentRoute = authenticatedProcedure
       data: {
         type: EnvelopeType.DOCUMENT,
         title,
-        userTimezone: timezone,
+        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,
+          })),
+        })),
         folderId,
         envelopeItems: [
           {
@@ -50,11 +97,15 @@ export const createDocumentRoute = authenticatedProcedure
         ],
       },
       attachments,
-      normalizePdf: true,
+      meta: {
+        ...meta,
+        emailSettings: meta?.emailSettings ?? undefined,
+      },
       requestMetadata: ctx.metadata,
     });
 
     return {
-      legacyDocumentId: mapSecondaryIdToDocumentId(document.secondaryId),
+      envelopeId: document.id,
+      id: mapSecondaryIdToDocumentId(document.secondaryId),
     };
   });

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

@@ -1,25 +1,70 @@
 import { z } from 'zod';
+import { zfd } from 'zod-form-data';
 
-import { ZDocumentMetaTimezoneSchema } from '@documenso/lib/types/document-meta';
+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 { ZDocumentVisibilitySchema } from '@documenso/lib/types/document-visibility';
 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 { ZDocumentTitleSchema } from './schema';
+import { zodFormData } from '../../utils/zod-form-data';
+import { ZCreateRecipientSchema } from '../recipient-router/schema';
+import type { TrpcRouteMeta } from '../trpc';
+import { ZDocumentExternalIdSchema, 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(),
+  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({
@@ -29,11 +74,19 @@ export const ZCreateDocumentRequestSchema = z.object({
       }),
     )
     .optional(),
+  meta: ZDocumentMetaCreateSchema.optional(),
+});
+
+export const ZCreateDocumentRequestSchema = zodFormData({
+  payload: zfd.json(ZCreateDocumentPayloadSchema),
+  file: zfd.file(),
 });
 
 export const ZCreateDocumentResponseSchema = z.object({
-  legacyDocumentId: z.number(),
+  envelopeId: z.string(),
+  id: 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/delete-document.ts

@@ -1,12 +1,12 @@
 import { deleteDocument } from '@documenso/lib/server-only/document/delete-document';
 
+import { ZGenericSuccessResponse } from '../schema';
 import { authenticatedProcedure } from '../trpc';
 import {
   ZDeleteDocumentRequestSchema,
   ZDeleteDocumentResponseSchema,
   deleteDocumentMeta,
 } from './delete-document.types';
-import { ZGenericSuccessResponse } from './schema';
 
 export const deleteDocumentRoute = authenticatedProcedure
   .meta(deleteDocumentMeta)

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../schema';
 import type { TrpcRouteMeta } from '../trpc';
-import { ZSuccessResponseSchema } from './schema';
 
 export const deleteDocumentMeta: TrpcRouteMeta = {
   openapi: {

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

@@ -0,0 +1,96 @@
+import type { DocumentData } from '@prisma/client';
+import { DocumentDataType, EnvelopeType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { getPresignGetUrl } from '@documenso/lib/universal/upload/server-actions';
+import { isDocumentCompleted } from '@documenso/lib/utils/document';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZDownloadDocumentRequestSchema,
+  ZDownloadDocumentResponseSchema,
+  downloadDocumentMeta,
+} from './download-document-beta.types';
+
+export const downloadDocumentBetaRoute = authenticatedProcedure
+  .meta(downloadDocumentMeta)
+  .input(ZDownloadDocumentRequestSchema)
+  .output(ZDownloadDocumentResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { documentId, version } = input;
+
+    ctx.logger.info({
+      input: {
+        documentId,
+        version,
+      },
+    });
+
+    const envelope = await getEnvelopeById({
+      id: {
+        type: 'documentId',
+        id: documentId,
+      },
+      type: EnvelopeType.DOCUMENT,
+      userId: user.id,
+      teamId,
+    });
+
+    // This error is done AFTER the get envelope so we can test access controls without S3.
+    if (process.env.NEXT_PUBLIC_UPLOAD_TRANSPORT !== 's3') {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Document downloads are only available when S3 storage is configured.',
+      });
+    }
+
+    const documentData: DocumentData | undefined = envelope.envelopeItems[0]?.documentData;
+
+    if (envelope.envelopeItems.length !== 1 || !documentData) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message:
+          'This endpoint only supports documents with a single item. Use envelopes API instead.',
+      });
+    }
+
+    if (documentData.type !== DocumentDataType.S3_PATH) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Document is not stored in S3 and cannot be downloaded via URL.',
+      });
+    }
+
+    if (version === 'signed' && !isDocumentCompleted(envelope.status)) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Document is not completed yet.',
+      });
+    }
+
+    try {
+      const data =
+        version === 'original' ? documentData.initialData || documentData.data : documentData.data;
+
+      const { url } = await getPresignGetUrl(data);
+
+      const baseTitle = envelope.title.replace(/\.pdf$/, '');
+      const suffix = version === 'signed' ? '_signed.pdf' : '.pdf';
+      const filename = `${baseTitle}${suffix}`;
+
+      return {
+        downloadUrl: url,
+        filename,
+        contentType: 'application/pdf',
+      };
+    } catch (error) {
+      ctx.logger.error({
+        error,
+        message: 'Failed to generate download URL',
+        documentId,
+        version,
+      });
+
+      throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+        message: 'Failed to generate download URL',
+      });
+    }
+  });

packages/trpc/server/document-router/download-document-beta.types.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+import type { TrpcRouteMeta } from '../trpc';
+
+export const downloadDocumentMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/document/{documentId}/download-beta',
+    summary: 'Download document (beta)',
+    description: 'Get a pre-signed download URL for the original or signed version of a document',
+    tags: ['Document'],
+  },
+};
+
+export const ZDownloadDocumentRequestSchema = z.object({
+  documentId: z.number().describe('The ID of the document to download.'),
+  version: z
+    .enum(['original', 'signed'])
+    .describe(
+      'The version of the document to download. "signed" returns the completed document with signatures, "original" returns the original uploaded document.',
+    )
+    .default('signed'),
+});
+
+export const ZDownloadDocumentResponseSchema = z.object({
+  downloadUrl: z.string().describe('Pre-signed URL for downloading the PDF file'),
+  filename: z.string().describe('The filename of the PDF file'),
+  contentType: z.string().describe('MIME type of the file'),
+});
+
+export type TDownloadDocumentRequest = z.infer<typeof ZDownloadDocumentRequestSchema>;
+export type TDownloadDocumentResponse = z.infer<typeof ZDownloadDocumentResponseSchema>;

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

@@ -1,11 +1,3 @@
-import type { DocumentData } from '@prisma/client';
-import { DocumentDataType, EnvelopeType } from '@prisma/client';
-
-import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
-import { getPresignGetUrl } from '@documenso/lib/universal/upload/server-actions';
-import { isDocumentCompleted } from '@documenso/lib/utils/document';
-
 import { authenticatedProcedure } from '../trpc';
 import {
   ZDownloadDocumentRequestSchema,
@@ -17,8 +9,7 @@ export const downloadDocumentRoute = authenticatedProcedure
   .meta(downloadDocumentMeta)
   .input(ZDownloadDocumentRequestSchema)
   .output(ZDownloadDocumentResponseSchema)
-  .query(async ({ input, ctx }) => {
-    const { teamId, user } = ctx;
+  .query(({ input, ctx }) => {
     const { documentId, version } = input;
 
     ctx.logger.info({
@@ -28,69 +19,6 @@ export const downloadDocumentRoute = authenticatedProcedure
       },
     });
 
-    const envelope = await getEnvelopeById({
-      id: {
-        type: 'documentId',
-        id: documentId,
-      },
-      type: EnvelopeType.DOCUMENT,
-      userId: user.id,
-      teamId,
-    });
-
-    // This error is done AFTER the get envelope so we can test access controls without S3.
-    if (process.env.NEXT_PUBLIC_UPLOAD_TRANSPORT !== 's3') {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message: 'Document downloads are only available when S3 storage is configured.',
-      });
-    }
-
-    const documentData: DocumentData | undefined = envelope.envelopeItems[0]?.documentData;
-
-    if (envelope.envelopeItems.length !== 1 || !documentData) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message:
-          'This endpoint only supports documents with a single item. Use envelopes API instead.',
-      });
-    }
-
-    if (documentData.type !== DocumentDataType.S3_PATH) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message: 'Document is not stored in S3 and cannot be downloaded via URL.',
-      });
-    }
-
-    if (version === 'signed' && !isDocumentCompleted(envelope.status)) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message: 'Document is not completed yet.',
-      });
-    }
-
-    try {
-      const data =
-        version === 'original' ? documentData.initialData || documentData.data : documentData.data;
-
-      const { url } = await getPresignGetUrl(data);
-
-      const baseTitle = envelope.title.replace(/\.pdf$/, '');
-      const suffix = version === 'signed' ? '_signed.pdf' : '.pdf';
-      const filename = `${baseTitle}${suffix}`;
-
-      return {
-        downloadUrl: url,
-        filename,
-        contentType: 'application/pdf',
-      };
-    } catch (error) {
-      ctx.logger.error({
-        error,
-        message: 'Failed to generate download URL',
-        documentId,
-        version,
-      });
-
-      throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
-        message: 'Failed to generate download URL',
-      });
-    }
+    // This endpoint is purely for V2 API, which is implemented in the Hono remix server.
+    throw new Error('NOT_IMPLEMENTED');
   });

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

@@ -5,10 +5,12 @@ import type { TrpcRouteMeta } from '../trpc';
 export const downloadDocumentMeta: TrpcRouteMeta = {
   openapi: {
     method: 'GET',
-    path: '/document/{documentId}/download-beta',
-    summary: 'Download document (beta)',
-    description: 'Get a pre-signed download URL for the original or signed version of a document',
+    path: '/document/{documentId}/download',
+    summary: 'Download document',
     tags: ['Document'],
+    responseHeaders: z.object({
+      'Content-Type': z.literal('application/pdf'),
+    }),
   },
 };
 
@@ -22,11 +24,7 @@ export const ZDownloadDocumentRequestSchema = z.object({
     .default('signed'),
 });
 
-export const ZDownloadDocumentResponseSchema = z.object({
-  downloadUrl: z.string().describe('Pre-signed URL for downloading the PDF file'),
-  filename: z.string().describe('The filename of the PDF file'),
-  contentType: z.string().describe('MIME type of the file'),
-});
+export const ZDownloadDocumentResponseSchema = z.instanceof(Uint8Array);
 
 export type TDownloadDocumentRequest = z.infer<typeof ZDownloadDocumentRequestSchema>;
 export type TDownloadDocumentResponse = z.infer<typeof ZDownloadDocumentResponseSchema>;

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

@@ -92,6 +92,14 @@ export const findInbox = async ({ userId, page = 1, perPage = 10, orderBy }: Fin
             url: true,
           },
         },
+        envelopeItems: {
+          select: {
+            id: true,
+            envelopeId: true,
+            title: true,
+            order: true,
+          },
+        },
       },
     }),
     prisma.envelope.count({

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

@@ -1,12 +1,12 @@
 import { resendDocument } from '@documenso/lib/server-only/document/resend-document';
 
+import { ZGenericSuccessResponse } from '../schema';
 import { authenticatedProcedure } from '../trpc';
 import {
   ZRedistributeDocumentRequestSchema,
   ZRedistributeDocumentResponseSchema,
   redistributeDocumentMeta,
 } from './redistribute-document.types';
-import { ZGenericSuccessResponse } from './schema';
 
 export const redistributeDocumentRoute = authenticatedProcedure
   .meta(redistributeDocumentMeta)

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../schema';
 import type { TrpcRouteMeta } from '../trpc';
-import { ZSuccessResponseSchema } from './schema';
 
 export const redistributeDocumentMeta: TrpcRouteMeta = {
   openapi: {

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

@@ -10,6 +10,7 @@ import { deleteDocumentRoute } from './delete-document';
 import { distributeDocumentRoute } from './distribute-document';
 import { downloadDocumentRoute } from './download-document';
 import { downloadDocumentAuditLogsRoute } from './download-document-audit-logs';
+import { downloadDocumentBetaRoute } from './download-document-beta';
 import { downloadDocumentCertificateRoute } from './download-document-certificate';
 import { duplicateDocumentRoute } from './duplicate-document';
 import { findDocumentAuditLogsRoute } from './find-document-audit-logs';
@@ -37,8 +38,10 @@ export const documentRouter = router({
   search: searchDocumentRoute,
   share: shareDocumentRoute,
 
-  // Temporary v2 beta routes to be removed once V2 is fully released.
   download: downloadDocumentRoute,
+
+  // Deprecated endpoints which need to be removed in the future.
+  downloadBeta: downloadDocumentBetaRoute,
   createDocumentTemporary: createDocumentTemporaryRoute,
 
   // Internal document routes for custom frontend requests.

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

@@ -1,19 +1,6 @@
 import { DocumentVisibility } from '@prisma/client';
 import { z } from 'zod';
 
-/**
- * Required for empty responses since we currently can't 201 requests for our openapi setup.
- *
- * Without this it will throw an error in Speakeasy SDK when it tries to parse an empty response.
- */
-export const ZSuccessResponseSchema = z.object({
-  success: z.literal(true),
-});
-
-export const ZGenericSuccessResponse = {
-  success: true,
-} satisfies z.infer<typeof ZSuccessResponseSchema>;
-
 export const ZDocumentTitleSchema = z
   .string()
   .trim()

packages/trpc/server/embedding-router/_router.ts

@@ -1,5 +1,4 @@
 import { router } from '../trpc';
-import { applyMultiSignSignatureRoute } from './apply-multi-sign-signature';
 import { createEmbeddingDocumentRoute } from './create-embedding-document';
 import { createEmbeddingPresignTokenRoute } from './create-embedding-presign-token';
 import { createEmbeddingTemplateRoute } from './create-embedding-template';
@@ -15,6 +14,6 @@ export const embeddingPresignRouter = router({
   createEmbeddingTemplate: createEmbeddingTemplateRoute,
   updateEmbeddingDocument: updateEmbeddingDocumentRoute,
   updateEmbeddingTemplate: updateEmbeddingTemplateRoute,
-  applyMultiSignSignature: applyMultiSignSignatureRoute,
+  // applyMultiSignSignature: applyMultiSignSignatureRoute,
   getMultiSignDocument: getMultiSignDocumentRoute,
 });

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

@@ -21,33 +21,38 @@ import {
   ZFieldWidthSchema,
 } from '@documenso/lib/types/field';
 import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+import { RecipientRole } from '@documenso/prisma/client';
 import { DocumentSigningOrder } from '@documenso/prisma/generated/types';
 
 import { ZDocumentExternalIdSchema, ZDocumentTitleSchema } from '../document-router/schema';
-import { ZCreateRecipientSchema } from '../recipient-router/schema';
 
 export const ZCreateEmbeddingDocumentRequestSchema = z.object({
   title: ZDocumentTitleSchema,
   documentDataId: z.string(),
   externalId: ZDocumentExternalIdSchema.optional(),
-  recipients: z
-    .array(
-      ZCreateRecipientSchema.extend({
-        fields: ZFieldAndMetaSchema.and(
-          z.object({
-            pageNumber: ZFieldPageNumberSchema,
-            pageX: ZFieldPageXSchema,
-            pageY: ZFieldPageYSchema,
-            width: ZFieldWidthSchema,
-            height: ZFieldHeightSchema,
-          }),
-        )
-          .array()
-          .optional(),
-      }),
-    )
-
-    .optional(),
+  recipients: z.array(
+    z.object({
+      id: z.number().optional(),
+      email: z.string().email(),
+      name: z.string(),
+      role: z.nativeEnum(RecipientRole),
+      signingOrder: z.number().optional(),
+      // We have an any cast so any changes here you need to update it in the embeding document edit page
+      // Search: "map<any>" to find it
+      fields: ZFieldAndMetaSchema.and(
+        z.object({
+          id: z.number().optional(),
+          pageNumber: ZFieldPageNumberSchema,
+          pageX: ZFieldPageXSchema,
+          pageY: ZFieldPageYSchema,
+          width: ZFieldWidthSchema,
+          height: ZFieldHeightSchema,
+        }),
+      )
+        .array()
+        .optional(),
+    }),
+  ),
   meta: z
     .object({
       subject: ZDocumentMetaSubjectSchema.optional(),

packages/trpc/server/embedding-router/create-embedding-template.types.ts

@@ -1,4 +1,4 @@
-import { DocumentSigningOrder, FieldType, RecipientRole } from '@prisma/client';
+import { DocumentSigningOrder, RecipientRole } from '@prisma/client';
 import { z } from 'zod';
 
 import { ZDocumentEmailSettingsSchema } from '@documenso/lib/types/document-email';
@@ -21,30 +21,33 @@ import {
   ZFieldPageYSchema,
   ZFieldWidthSchema,
 } from '@documenso/lib/types/field';
-import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
 
 import { ZDocumentTitleSchema } from '../document-router/schema';
 
-const ZFieldSchema = z.object({
-  type: z.nativeEnum(FieldType),
-  pageNumber: ZFieldPageNumberSchema,
-  pageX: ZFieldPageXSchema,
-  pageY: ZFieldPageYSchema,
-  width: ZFieldWidthSchema,
-  height: ZFieldHeightSchema,
-  fieldMeta: ZFieldMetaSchema.optional(),
-});
-
 export const ZCreateEmbeddingTemplateRequestSchema = z.object({
   title: ZDocumentTitleSchema,
   documentDataId: z.string(),
   recipients: z.array(
     z.object({
-      email: z.string().email(),
-      name: z.string().optional(),
-      role: z.nativeEnum(RecipientRole).optional(),
+      email: z.union([z.string().length(0), z.string().email()]),
+      name: z.string(),
+      role: z.nativeEnum(RecipientRole),
       signingOrder: z.number().optional(),
-      fields: z.array(ZFieldSchema).optional(),
+      // We have an any cast so any changes here you need to update it in the embeding document edit page
+      // Search: "map<any>" to find it
+      fields: ZFieldAndMetaSchema.and(
+        z.object({
+          id: z.number().optional(),
+          pageNumber: ZFieldPageNumberSchema,
+          pageX: ZFieldPageXSchema,
+          pageY: ZFieldPageYSchema,
+          width: ZFieldWidthSchema,
+          height: ZFieldHeightSchema,
+        }),
+      )
+        .array()
+        .optional(),
     }),
   ),
   meta: z

packages/trpc/server/embedding-router/get-multi-sign-document.types.ts

@@ -4,6 +4,7 @@ import { ZDocumentLiteSchema } from '@documenso/lib/types/document';
 import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
 import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
 import DocumentMetaSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentMetaSchema';
+import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
 import FieldSchema from '@documenso/prisma/generated/zod/modelSchema/FieldSchema';
 import SignatureSchema from '@documenso/prisma/generated/zod/modelSchema/SignatureSchema';
 
@@ -40,6 +41,10 @@ export const ZGetMultiSignDocumentResponseSchema = ZDocumentLiteSchema.extend({
       signature: SignatureSchema.nullable(),
     }),
   ),
+  envelopeItems: EnvelopeItemSchema.pick({
+    id: true,
+    envelopeId: true,
+  }).array(),
 });
 
 export type TGetMultiSignDocumentRequestSchema = z.infer<typeof ZGetMultiSignDocumentRequestSchema>;

packages/trpc/server/embedding-router/update-embedding-document.types.ts

@@ -32,7 +32,7 @@ export const ZUpdateEmbeddingDocumentRequestSchema = z.object({
   recipients: z.array(
     z.object({
       id: z.number().optional(),
-      email: z.string().toLowerCase().email().min(1),
+      email: z.string().email(),
       name: z.string(),
       role: z.nativeEnum(RecipientRole),
       signingOrder: z.number().optional(),

packages/trpc/server/embedding-router/update-embedding-template.ts

@@ -3,7 +3,6 @@ import { verifyEmbeddingPresignToken } from '@documenso/lib/server-only/embeddin
 import { updateEnvelope } from '@documenso/lib/server-only/envelope/update-envelope';
 import { setFieldsForTemplate } from '@documenso/lib/server-only/field/set-fields-for-template';
 import { setTemplateRecipients } from '@documenso/lib/server-only/recipient/set-template-recipients';
-import { nanoid } from '@documenso/lib/universal/id';
 
 import { procedure } from '../trpc';
 import {
@@ -53,11 +52,6 @@ export const updateEmbeddingTemplateRoute = procedure
         requestMetadata: ctx.metadata,
       });
 
-      const recipientsWithClientId = recipients.map((recipient) => ({
-        ...recipient,
-        clientId: nanoid(),
-      }));
-
       const { recipients: updatedRecipients } = await setTemplateRecipients({
         userId: apiToken.userId,
         teamId: apiToken.teamId ?? undefined,
@@ -65,7 +59,7 @@ export const updateEmbeddingTemplateRoute = procedure
           type: 'templateId',
           id: templateId,
         },
-        recipients: recipientsWithClientId.map((recipient) => ({
+        recipients: recipients.map((recipient) => ({
           id: recipient.id,
           email: recipient.email,
           name: recipient.name ?? '',
@@ -74,8 +68,8 @@ export const updateEmbeddingTemplateRoute = procedure
         })),
       });
 
-      const fields = recipientsWithClientId.flatMap((recipient) => {
-        const recipientId = updatedRecipients.find((r) => r.email === recipient.email)?.id;
+      const fields = recipients.flatMap((recipient) => {
+        const recipientId = updatedRecipients.find((r) => r.id === recipient.id)?.id;
 
         if (!recipientId) {
           throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
@@ -86,8 +80,6 @@ export const updateEmbeddingTemplateRoute = procedure
         return (recipient.fields ?? []).map((field) => ({
           ...field,
           recipientId,
-          // !: Temp property to be removed once we don't link based on signer email
-          signerEmail: recipient.email,
         }));
       });
 

packages/trpc/server/embedding-router/update-embedding-template.types.ts

@@ -21,7 +21,7 @@ import {
   ZFieldPageYSchema,
   ZFieldWidthSchema,
 } from '@documenso/lib/types/field';
-import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
+import { ZFieldAndMetaSchema, ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
 
 import { ZDocumentTitleSchema } from '../document-router/schema';
 
@@ -44,11 +44,25 @@ export const ZUpdateEmbeddingTemplateRequestSchema = z.object({
   recipients: z.array(
     z.object({
       id: z.number().optional(),
-      email: z.string().email(),
-      name: z.string().optional(),
-      role: z.nativeEnum(RecipientRole).optional(),
+      email: z.union([z.string().length(0), z.string().email()]),
+      name: z.string(),
+      role: z.nativeEnum(RecipientRole),
       signingOrder: z.number().optional(),
-      fields: z.array(ZFieldSchema).optional(),
+      // We have an any cast so any changes here you need to update it in the embeding document edit page
+      // Search: "map<any>" to find it
+      fields: ZFieldAndMetaSchema.and(
+        z.object({
+          id: z.number().optional(),
+          pageNumber: ZFieldPageNumberSchema,
+          pageX: ZFieldPageXSchema,
+          pageY: ZFieldPageYSchema,
+          width: ZFieldWidthSchema,
+          height: ZFieldHeightSchema,
+          envelopeItemId: z.string(),
+        }),
+      )
+        .array()
+        .optional(),
     }),
   ),
   meta: z

packages/trpc/server/enterprise-router/create-subscription.ts

@@ -71,7 +71,7 @@ export const createSubscriptionRoute = authenticatedProcedure
     }
 
     const returnUrl = isPersonalLayoutMode
-      ? `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing`
+      ? `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing-personal`
       : `${NEXT_PUBLIC_WEBAPP_URL()}/o/${organisation.url}/settings/billing`;
 
     const redirectUrl = await createCheckoutSession({

packages/trpc/server/enterprise-router/manage-subscription.ts

@@ -12,7 +12,7 @@ import { ZManageSubscriptionRequestSchema } from './manage-subscription.types';
 export const manageSubscriptionRoute = authenticatedProcedure
   .input(ZManageSubscriptionRequestSchema)
   .mutation(async ({ ctx, input }) => {
-    const { organisationId } = input;
+    const { organisationId, isPersonalLayoutMode } = input;
 
     ctx.logger.info({
       input: {
@@ -93,9 +93,13 @@ export const manageSubscriptionRoute = authenticatedProcedure
       });
     }
 
+    const returnUrl = isPersonalLayoutMode
+      ? `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing-personal`
+      : `${NEXT_PUBLIC_WEBAPP_URL()}/o/${organisation.url}/settings/billing`;
+
     const redirectUrl = await getPortalSession({
       customerId,
-      returnUrl: `${NEXT_PUBLIC_WEBAPP_URL()}/o/${organisation.url}/settings/billing`,
+      returnUrl,
     });
 
     return {

packages/trpc/server/enterprise-router/manage-subscription.types.ts

@@ -2,4 +2,5 @@ import { z } from 'zod';
 
 export const ZManageSubscriptionRequestSchema = z.object({
   organisationId: z.string().describe('The organisation to manage the subscription for'),
+  isPersonalLayoutMode: z.boolean().optional(),
 });

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

@@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
 import {
   ZCreateAttachmentRequestSchema,
   ZCreateAttachmentResponseSchema,
+  createAttachmentMeta,
 } from './create-attachment.types';
 
 export const createAttachmentRoute = authenticatedProcedure
-  .meta({
-    openapi: {
-      method: 'POST',
-      path: '/envelope/attachment/create',
-      summary: 'Create attachment',
-      description: 'Create a new attachment for an envelope',
-      tags: ['Envelope'],
-    },
-  })
+  .meta(createAttachmentMeta)
   .input(ZCreateAttachmentRequestSchema)
   .output(ZCreateAttachmentResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -28,10 +21,14 @@ export const createAttachmentRoute = authenticatedProcedure
       input: { envelopeId, label: data.label },
     });
 
-    await createAttachment({
+    const attachment = await createAttachment({
       envelopeId,
       teamId,
       userId,
       data,
     });
+
+    return {
+      id: attachment.id,
+    };
   });

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

@@ -1,5 +1,17 @@
 import { z } from 'zod';
 
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const createAttachmentMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/attachment/create',
+    summary: 'Create attachment',
+    description: 'Create a new attachment for an envelope',
+    tags: ['Envelope Attachments'],
+  },
+};
+
 export const ZCreateAttachmentRequestSchema = z.object({
   envelopeId: z.string(),
   data: z.object({
@@ -8,7 +20,9 @@ export const ZCreateAttachmentRequestSchema = z.object({
   }),
 });
 
-export const ZCreateAttachmentResponseSchema = z.void();
+export const ZCreateAttachmentResponseSchema = z.object({
+  id: z.string(),
+});
 
 export type TCreateAttachmentRequest = z.infer<typeof ZCreateAttachmentRequestSchema>;
 export type TCreateAttachmentResponse = z.infer<typeof ZCreateAttachmentResponseSchema>;

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

@@ -1,21 +1,15 @@
 import { deleteAttachment } from '@documenso/lib/server-only/envelope-attachment/delete-attachment';
 
+import { ZGenericSuccessResponse } from '../../schema';
 import { authenticatedProcedure } from '../../trpc';
 import {
   ZDeleteAttachmentRequestSchema,
   ZDeleteAttachmentResponseSchema,
+  deleteAttachmentMeta,
 } from './delete-attachment.types';
 
 export const deleteAttachmentRoute = authenticatedProcedure
-  .meta({
-    openapi: {
-      method: 'POST',
-      path: '/envelope/attachment/delete',
-      summary: 'Delete attachment',
-      description: 'Delete an attachment from an envelope',
-      tags: ['Envelope'],
-    },
-  })
+  .meta(deleteAttachmentMeta)
   .input(ZDeleteAttachmentRequestSchema)
   .output(ZDeleteAttachmentResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -33,4 +27,6 @@ export const deleteAttachmentRoute = authenticatedProcedure
       userId,
       teamId,
     });
+
+    return ZGenericSuccessResponse;
   });

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

@@ -1,10 +1,23 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../../schema';
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const deleteAttachmentMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/attachment/delete',
+    summary: 'Delete attachment',
+    description: 'Delete an attachment from an envelope',
+    tags: ['Envelope Attachments'],
+  },
+};
+
 export const ZDeleteAttachmentRequestSchema = z.object({
   id: z.string(),
 });
 
-export const ZDeleteAttachmentResponseSchema = z.void();
+export const ZDeleteAttachmentResponseSchema = ZSuccessResponseSchema;
 
 export type TDeleteAttachmentRequest = z.infer<typeof ZDeleteAttachmentRequestSchema>;
 export type TDeleteAttachmentResponse = z.infer<typeof ZDeleteAttachmentResponseSchema>;

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

@@ -2,22 +2,15 @@ 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,
+  findAttachmentsMeta,
 } from './find-attachments.types';
 
-export const findAttachmentsRoute = procedure
-  .meta({
-    openapi: {
-      method: 'GET',
-      path: '/envelope/attachment',
-      summary: 'Find attachments',
-      description: 'Find all attachments for an envelope',
-      tags: ['Envelope'],
-    },
-  })
+export const findAttachmentsRoute = maybeAuthenticatedProcedure
+  .meta(findAttachmentsMeta)
   .input(ZFindAttachmentsRequestSchema)
   .output(ZFindAttachmentsResponseSchema)
   .query(async ({ input, ctx }) => {

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

@@ -2,6 +2,18 @@ import { z } from 'zod';
 
 import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
 
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const findAttachmentsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/envelope/attachment',
+    summary: 'Find attachments',
+    description: 'Find all attachments for an envelope',
+    tags: ['Envelope Attachments'],
+  },
+};
+
 export const ZFindAttachmentsRequestSchema = z.object({
   envelopeId: z.string(),
   token: z.string().optional(),

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

@@ -1,21 +1,15 @@
 import { updateAttachment } from '@documenso/lib/server-only/envelope-attachment/update-attachment';
 
+import { ZGenericSuccessResponse } from '../../schema';
 import { authenticatedProcedure } from '../../trpc';
 import {
   ZUpdateAttachmentRequestSchema,
   ZUpdateAttachmentResponseSchema,
+  updateAttachmentMeta,
 } from './update-attachment.types';
 
 export const updateAttachmentRoute = authenticatedProcedure
-  .meta({
-    openapi: {
-      method: 'POST',
-      path: '/envelope/attachment/update',
-      summary: 'Update attachment',
-      description: 'Update an existing attachment',
-      tags: ['Envelope'],
-    },
-  })
+  .meta(updateAttachmentMeta)
   .input(ZUpdateAttachmentRequestSchema)
   .output(ZUpdateAttachmentResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -34,4 +28,6 @@ export const updateAttachmentRoute = authenticatedProcedure
       teamId,
       data,
     });
+
+    return ZGenericSuccessResponse;
   });

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

@@ -1,5 +1,18 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../../schema';
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const updateAttachmentMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/attachment/update',
+    summary: 'Update attachment',
+    description: 'Update an existing attachment',
+    tags: ['Envelope Attachments'],
+  },
+};
+
 export const ZUpdateAttachmentRequestSchema = z.object({
   id: z.string(),
   data: z.object({
@@ -8,7 +21,7 @@ export const ZUpdateAttachmentRequestSchema = z.object({
   }),
 });
 
-export const ZUpdateAttachmentResponseSchema = z.void();
+export const ZUpdateAttachmentResponseSchema = ZSuccessResponseSchema;
 
 export type TUpdateAttachmentRequest = z.infer<typeof ZUpdateAttachmentRequestSchema>;
 export type TUpdateAttachmentResponse = z.infer<typeof ZUpdateAttachmentResponseSchema>;

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

@@ -2,6 +2,7 @@ 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 { prefixedId } from '@documenso/lib/universal/id';
+import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
 import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
 import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
 import { prisma } from '@documenso/prisma';
@@ -10,14 +11,17 @@ import { authenticatedProcedure } from '../trpc';
 import {
   ZCreateEnvelopeItemsRequestSchema,
   ZCreateEnvelopeItemsResponseSchema,
+  createEnvelopeItemsMeta,
 } from './create-envelope-items.types';
 
 export const createEnvelopeItemsRoute = authenticatedProcedure
+  .meta(createEnvelopeItemsMeta)
   .input(ZCreateEnvelopeItemsRequestSchema)
   .output(ZCreateEnvelopeItemsResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId, metadata } = ctx;
-    const { envelopeId, items } = input;
+    const { payload, files } = input;
+    const { envelopeId } = payload;
 
     ctx.logger.info({
       input: {
@@ -71,7 +75,7 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
     const organisationClaim = envelope.team.organisation.organisationClaim;
 
     const remainingEnvelopeItems =
-      organisationClaim.envelopeItemCount - envelope.envelopeItems.length - items.length;
+      organisationClaim.envelopeItemCount - envelope.envelopeItems.length - files.length;
 
     if (remainingEnvelopeItems < 0) {
       throw new AppError('ENVELOPE_ITEM_LIMIT_EXCEEDED', {
@@ -80,41 +84,24 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
       });
     }
 
-    const foundDocumentData = await prisma.documentData.findMany({
-      where: {
-        id: {
-          in: items.map((item) => item.documentDataId),
-        },
-      },
-      select: {
-        envelopeItem: {
-          select: {
-            id: true,
-          },
-        },
-      },
-    });
+    // 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);
 
-    // Check that all the document data was found.
-    if (foundDocumentData.length !== items.length) {
-      throw new AppError(AppErrorCode.NOT_FOUND, {
-        message: 'Document data not found',
-      });
-    }
-
-    // Check that it doesn't already have an envelope item.
-    if (foundDocumentData.some((documentData) => documentData.envelopeItem?.id)) {
-      throw new AppError(AppErrorCode.INVALID_REQUEST, {
-        message: 'Document data not found',
-      });
-    }
+        return {
+          title: file.name,
+          documentDataId,
+        };
+      }),
+    );
 
     const currentHighestOrderValue =
       envelope.envelopeItems[envelope.envelopeItems.length - 1]?.order ?? 1;
 
     const result = await prisma.$transaction(async (tx) => {
       const createdItems = await tx.envelopeItem.createManyAndReturn({
-        data: items.map((item) => ({
+        data: envelopeItems.map((item) => ({
           id: prefixedId('envelope_item'),
           envelopeId,
           title: item.title,
@@ -148,6 +135,6 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
     });
 
     return {
-      createdEnvelopeItems: result,
+      data: result,
     };
   });

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

@@ -1,38 +1,41 @@
 import { z } from 'zod';
+import { zfd } from 'zod-form-data';
 
-import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
 import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
 
-import { ZDocumentTitleSchema } from '../document-router/schema';
+import { zodFormData } from '../../utils/zod-form-data';
+import type { TrpcRouteMeta } from '../trpc';
 
-export const ZCreateEnvelopeItemsRequestSchema = z.object({
+export const createEnvelopeItemsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/item/create-many',
+    summary: 'Create envelope items',
+    contentTypes: ['multipart/form-data'],
+    description: 'Create multiple envelope items for an envelope',
+    tags: ['Envelope Items'],
+  },
+};
+
+export const ZCreateEnvelopeItemsPayloadSchema = z.object({
   envelopeId: z.string(),
-  items: z
-    .object({
-      title: ZDocumentTitleSchema,
-      documentDataId: z.string(),
-    })
-    .array(),
+  // data: z.object() // Currently not used.
+});
+
+export const ZCreateEnvelopeItemsRequestSchema = zodFormData({
+  payload: zfd.json(ZCreateEnvelopeItemsPayloadSchema),
+  files: zfd.repeatableOfType(zfd.file()),
 });
 
 export const ZCreateEnvelopeItemsResponseSchema = z.object({
-  createdEnvelopeItems: EnvelopeItemSchema.pick({
+  data: EnvelopeItemSchema.pick({
     id: true,
     title: true,
-    documentDataId: true,
     envelopeId: true,
     order: true,
-  })
-    .extend({
-      documentData: DocumentDataSchema.pick({
-        type: true,
-        id: true,
-        data: true,
-        initialData: true,
-      }),
-    })
-    .array(),
+  }).array(),
 });
 
+export type TCreateEnvelopeItemsPayload = z.infer<typeof ZCreateEnvelopeItemsPayloadSchema>;
 export type TCreateEnvelopeItemsRequest = z.infer<typeof ZCreateEnvelopeItemsRequestSchema>;
 export type TCreateEnvelopeItemsResponse = z.infer<typeof ZCreateEnvelopeItemsResponseSchema>;

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

@@ -1,18 +1,25 @@
 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 { insertFormValuesInPdf } from '../../../lib/server-only/pdf/insert-form-values-in-pdf';
 import { authenticatedProcedure } from '../trpc';
 import {
   ZCreateEnvelopeRequestSchema,
   ZCreateEnvelopeResponseSchema,
+  createEnvelopeMeta,
 } from './create-envelope.types';
 
 export const createEnvelopeRoute = authenticatedProcedure
+  .meta(createEnvelopeMeta)
   .input(ZCreateEnvelopeRequestSchema)
   .output(ZCreateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { user, teamId } = ctx;
+
+    const { payload, files } = input;
+
     const {
       title,
       type,
@@ -20,12 +27,12 @@ export const createEnvelopeRoute = authenticatedProcedure
       visibility,
       globalAccessAuth,
       globalActionAuth,
+      formValues,
       recipients,
       folderId,
-      items,
       meta,
       attachments,
-    } = input;
+    } = payload;
 
     ctx.logger.info({
       input: {
@@ -45,13 +52,83 @@ 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,
       });
     }
 
+    if (files.some((file) => !file.type.startsWith('application/pdf'))) {
+      throw new AppError('INVALID_DOCUMENT_FILE', {
+        message: 'You cannot upload non-PDF files',
+        statusCode: 400,
+      });
+    }
+
+    // For each file, stream to s3 and create the document data.
+    const envelopeItems = await Promise.all(
+      files.map(async (file) => {
+        let pdf = Buffer.from(await file.arrayBuffer());
+
+        if (formValues) {
+          // eslint-disable-next-line require-atomic-updates
+          pdf = await insertFormValuesInPdf({
+            pdf,
+            formValues,
+          });
+        }
+
+        const { id: documentDataId } = await putNormalizedPdfFileServerSide({
+          name: file.name,
+          type: 'application/pdf',
+          arrayBuffer: async () => Promise.resolve(pdf),
+        });
+
+        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.at(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,
@@ -60,16 +137,16 @@ export const createEnvelopeRoute = authenticatedProcedure
         type,
         title,
         externalId,
+        formValues,
         visibility,
         globalAccessAuth,
         globalActionAuth,
-        recipients,
+        recipients: recipientsToCreate,
         folderId,
-        envelopeItems: items,
+        envelopeItems,
       },
       attachments,
       meta,
-      normalizePdf: true,
       requestMetadata: ctx.metadata,
     });
 

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,
@@ -9,32 +10,35 @@ import { ZDocumentFormValuesSchema } from '@documenso/lib/types/document-form-va
 import { ZDocumentMetaCreateSchema } from '@documenso/lib/types/document-meta';
 import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
 import {
-  ZFieldHeightSchema,
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
   ZFieldPageNumberSchema,
-  ZFieldPageXSchema,
-  ZFieldPageYSchema,
-  ZFieldWidthSchema,
 } from '@documenso/lib/types/field';
-import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+import { ZEnvelopeFieldAndMetaSchema } 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 an 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 +46,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(
@@ -57,18 +55,19 @@ export const ZCreateEnvelopeRequestSchema = z.object({
   recipients: z
     .array(
       ZCreateRecipientSchema.extend({
-        fields: ZFieldAndMetaSchema.and(
+        fields: ZEnvelopeFieldAndMetaSchema.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,
-            width: ZFieldWidthSchema,
-            height: ZFieldHeightSchema,
+            positionX: ZClampedFieldPositionXSchema,
+            positionY: ZClampedFieldPositionYSchema,
+            width: ZClampedFieldWidthSchema,
+            height: ZClampedFieldHeightSchema,
           }),
         )
           .array()
@@ -88,9 +87,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

@@ -5,13 +5,16 @@ import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-
 import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
 import { prisma } from '@documenso/prisma';
 
+import { ZGenericSuccessResponse } from '../schema';
 import { authenticatedProcedure } from '../trpc';
 import {
   ZDeleteEnvelopeItemRequestSchema,
   ZDeleteEnvelopeItemResponseSchema,
+  deleteEnvelopeItemMeta,
 } from './delete-envelope-item.types';
 
 export const deleteEnvelopeItemRoute = authenticatedProcedure
+  .meta(deleteEnvelopeItemMeta)
   .input(ZDeleteEnvelopeItemRequestSchema)
   .output(ZDeleteEnvelopeItemResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -98,4 +101,6 @@ export const deleteEnvelopeItemRoute = authenticatedProcedure
         },
       },
     });
+
+    return ZGenericSuccessResponse;
   });

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

@@ -1,11 +1,24 @@
 import { z } from 'zod';
 
+import { ZSuccessResponseSchema } from '../schema';
+import type { TrpcRouteMeta } from '../trpc';
+
+export const deleteEnvelopeItemMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/item/delete',
+    summary: 'Delete envelope item',
+    description: 'Delete an envelope item from an envelope',
+    tags: ['Envelope Items'],
+  },
+};
+
 export const ZDeleteEnvelopeItemRequestSchema = z.object({
   envelopeId: z.string(),
   envelopeItemId: z.string(),
 });
 
-export const ZDeleteEnvelopeItemResponseSchema = z.void();
+export const ZDeleteEnvelopeItemResponseSchema = ZSuccessResponseSchema;
 
 export type TDeleteEnvelopeItemRequest = z.infer<typeof ZDeleteEnvelopeItemRequestSchema>;
 export type TDeleteEnvelopeItemResponse = z.infer<typeof ZDeleteEnvelopeItemResponseSchema>;

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

@@ -1,22 +1,26 @@
 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 { ZGenericSuccessResponse } from '../schema';
 import { authenticatedProcedure } from '../trpc';
 import {
   ZDeleteEnvelopeRequestSchema,
   ZDeleteEnvelopeResponseSchema,
+  deleteEnvelopeMeta,
 } from './delete-envelope.types';
 
 export const deleteEnvelopeRoute = authenticatedProcedure
-  // .meta(deleteEnvelopeMeta)
+  .meta(deleteEnvelopeMeta)
   .input(ZDeleteEnvelopeRequestSchema)
   .output(ZDeleteEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
     const { teamId } = ctx;
-    const { envelopeId, envelopeType } = input;
+    const { envelopeId } = input;
 
     ctx.logger.info({
       input: {
@@ -24,7 +28,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,
@@ -47,4 +66,6 @@ export const deleteEnvelopeRoute = authenticatedProcedure
         }),
       )
       .exhaustive();
+
+    return ZGenericSuccessResponse;
   });

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

@@ -1,21 +1,22 @@
-import { EnvelopeType } from '@prisma/client';
 import { z } from 'zod';
 
-// export const deleteEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/delete',
-//     summary: 'Delete envelope',
-//     tags: ['Envelope'],
-//   },
-// };
+import { ZSuccessResponseSchema } from '../schema';
+import type { TrpcRouteMeta } from '../trpc';
+
+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();
+export const ZDeleteEnvelopeResponseSchema = ZSuccessResponseSchema;
 
 export type TDeleteEnvelopeRequest = z.infer<typeof ZDeleteEnvelopeRequestSchema>;
 export type TDeleteEnvelopeResponse = z.infer<typeof ZDeleteEnvelopeResponseSchema>;

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

@@ -1,14 +1,16 @@
 import { updateDocumentMeta } from '@documenso/lib/server-only/document-meta/upsert-document-meta';
 import { sendDocument } from '@documenso/lib/server-only/document/send-document';
+import { formatSigningLink } from '@documenso/lib/utils/recipients';
 
 import { authenticatedProcedure } from '../trpc';
 import {
   ZDistributeEnvelopeRequestSchema,
   ZDistributeEnvelopeResponseSchema,
+  distributeEnvelopeMeta,
 } from './distribute-envelope.types';
 
 export const distributeEnvelopeRoute = authenticatedProcedure
-  // .meta(distributeEnvelopeMeta)
+  .meta(distributeEnvelopeMeta)
   .input(ZDistributeEnvelopeRequestSchema)
   .output(ZDistributeEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -43,7 +45,7 @@ export const distributeEnvelopeRoute = authenticatedProcedure
       });
     }
 
-    await sendDocument({
+    const envelope = await sendDocument({
       userId: ctx.user.id,
       id: {
         type: 'envelopeId',
@@ -52,4 +54,18 @@ export const distributeEnvelopeRoute = authenticatedProcedure
       teamId,
       requestMetadata: ctx.metadata,
     });
+
+    return {
+      success: true,
+      id: envelope.id,
+      recipients: envelope.recipients.map((recipient) => ({
+        id: recipient.id,
+        name: recipient.name,
+        email: recipient.email,
+        token: recipient.token,
+        role: recipient.role,
+        signingOrder: recipient.signingOrder,
+        signingUrl: formatSigningLink(recipient.token),
+      })),
+    };
   });

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

@@ -2,15 +2,19 @@ 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'],
-//   },
-// };
+import { ZSuccessResponseSchema } from '../schema';
+import type { TrpcRouteMeta } from '../trpc';
+import { ZRecipientWithSigningUrlSchema } from './schema';
+
+export const distributeEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/distribute',
+    summary: 'Distribute envelope',
+    description: 'Send the envelope 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.'),
@@ -28,7 +32,10 @@ export const ZDistributeEnvelopeRequestSchema = z.object({
   }).optional(),
 });
 
-export const ZDistributeEnvelopeResponseSchema = z.void();
+export const ZDistributeEnvelopeResponseSchema = ZSuccessResponseSchema.extend({
+  id: z.string().describe('The ID of the envelope that was sent.'),
+  recipients: ZRecipientWithSigningUrlSchema.array(),
+});
 
 export type TDistributeEnvelopeRequest = z.infer<typeof ZDistributeEnvelopeRequestSchema>;
 export type TDistributeEnvelopeResponse = z.infer<typeof ZDistributeEnvelopeResponseSchema>;

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

@@ -0,0 +1,24 @@
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZDownloadEnvelopeItemRequestSchema,
+  ZDownloadEnvelopeItemResponseSchema,
+  downloadEnvelopeItemMeta,
+} from './download-envelope-item.types';
+
+export const downloadEnvelopeItemRoute = authenticatedProcedure
+  .meta(downloadEnvelopeItemMeta)
+  .input(ZDownloadEnvelopeItemRequestSchema)
+  .output(ZDownloadEnvelopeItemResponseSchema)
+  .query(({ input, ctx }) => {
+    const { envelopeItemId, version } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeItemId,
+        version,
+      },
+    });
+
+    // This endpoint is purely for V2 API, which is implemented in the Hono remix server.
+    throw new Error('NOT_IMPLEMENTED');
+  });

packages/trpc/server/envelope-router/download-envelope-item.types.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+
+import type { TrpcRouteMeta } from '../trpc';
+
+export const downloadEnvelopeItemMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/envelope/item/{envelopeItemId}/download',
+    summary: 'Download an envelope item',
+    description: 'Download an envelope item by its ID',
+    tags: ['Envelope Items'],
+    responseHeaders: z.object({
+      'Content-Type': z.literal('application/pdf'),
+    }),
+  },
+};
+
+export const ZDownloadEnvelopeItemRequestSchema = z.object({
+  envelopeItemId: z.string().describe('The ID of the envelope item to download.'),
+  version: z
+    .enum(['original', 'signed'])
+    .describe(
+      'The version of the envelope item to download. "signed" returns the completed document with signatures, "original" returns the original uploaded document.',
+    )
+    .default('signed'),
+});
+
+export const ZDownloadEnvelopeItemResponseSchema = z.instanceof(Uint8Array);
+
+export type TDownloadEnvelopeItemRequest = z.infer<typeof ZDownloadEnvelopeItemRequestSchema>;
+export type TDownloadEnvelopeItemResponse = z.infer<typeof ZDownloadEnvelopeItemResponseSchema>;

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

@@ -4,9 +4,11 @@ import { authenticatedProcedure } from '../trpc';
 import {
   ZDuplicateEnvelopeRequestSchema,
   ZDuplicateEnvelopeResponseSchema,
+  duplicateEnvelopeMeta,
 } from './duplicate-envelope.types';
 
 export const duplicateEnvelopeRoute = authenticatedProcedure
+  .meta(duplicateEnvelopeMeta)
   .input(ZDuplicateEnvelopeRequestSchema)
   .output(ZDuplicateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -29,6 +31,6 @@ export const duplicateEnvelopeRoute = authenticatedProcedure
     });
 
     return {
-      duplicatedEnvelopeId: duplicatedEnvelope.id,
+      id: duplicatedEnvelope.id,
     };
   });

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

@@ -1,11 +1,23 @@
 import { z } from 'zod';
 
+import type { TrpcRouteMeta } from '../trpc';
+
+export const duplicateEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/duplicate',
+    summary: 'Duplicate envelope',
+    description: 'Duplicate an envelope with all its settings',
+    tags: ['Envelope'],
+  },
+};
+
 export const ZDuplicateEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),
 });
 
 export const ZDuplicateEnvelopeResponseSchema = z.object({
-  duplicatedEnvelopeId: z.string(),
+  id: z.string().describe('The ID of the newly created envelope.'),
 });
 
 export type TDuplicateEnvelopeRequest = z.infer<typeof ZDuplicateEnvelopeRequestSchema>;

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

@@ -0,0 +1,38 @@
+import { createEnvelopeFields } from '@documenso/lib/server-only/field/create-envelope-fields';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZCreateEnvelopeFieldsRequestSchema,
+  ZCreateEnvelopeFieldsResponseSchema,
+  createEnvelopeFieldsMeta,
+} from './create-envelope-fields.types';
+
+export const createEnvelopeFieldsRoute = authenticatedProcedure
+  .meta(createEnvelopeFieldsMeta)
+  .input(ZCreateEnvelopeFieldsRequestSchema)
+  .output(ZCreateEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { envelopeId, data: fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const { fields: data } = await createEnvelopeFields({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      fields,
+      requestMetadata: metadata,
+    });
+
+    return {
+      data,
+    };
+  });

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZEnvelopeFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const createEnvelopeFieldsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/field/create-many',
+    summary: 'Create envelope fields',
+    description: 'Create multiple fields for an envelope',
+    tags: ['Envelope Fields'],
+  },
+};
+
+const ZCreateFieldSchema = ZEnvelopeFieldAndMetaSchema.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({
+  data: 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,121 @@
+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 { ZGenericSuccessResponse } from '../../schema';
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeFieldRequestSchema,
+  ZDeleteEnvelopeFieldResponseSchema,
+  deleteEnvelopeFieldMeta,
+} from './delete-envelope-field.types';
+
+export const deleteEnvelopeFieldRoute = authenticatedProcedure
+  .meta(deleteEnvelopeFieldMeta)
+  .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;
+    });
+
+    return ZGenericSuccessResponse;
+  });

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+
+import { ZSuccessResponseSchema } from '../../schema';
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const deleteEnvelopeFieldMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/field/delete',
+    summary: 'Delete envelope field',
+    description: 'Delete an envelope field',
+    tags: ['Envelope Fields'],
+  },
+};
+
+export const ZDeleteEnvelopeFieldRequestSchema = z.object({
+  fieldId: z.number(),
+});
+
+export const ZDeleteEnvelopeFieldResponseSchema = ZSuccessResponseSchema;
+
+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,29 @@
+import { getFieldById } from '@documenso/lib/server-only/field/get-field-by-id';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZGetEnvelopeFieldRequestSchema,
+  ZGetEnvelopeFieldResponseSchema,
+  getEnvelopeFieldMeta,
+} from './get-envelope-field.types';
+
+export const getEnvelopeFieldRoute = authenticatedProcedure
+  .meta(getEnvelopeFieldMeta)
+  .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,24 @@
+import { z } from 'zod';
+
+import { ZEnvelopeFieldSchema } from '@documenso/lib/types/field';
+
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const getEnvelopeFieldMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/envelope/field/{fieldId}',
+    summary: 'Get envelope field',
+    description: 'Returns an envelope field given an ID',
+    tags: ['Envelope Fields'],
+  },
+};
+
+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,39 @@
+import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZUpdateEnvelopeFieldsRequestSchema,
+  ZUpdateEnvelopeFieldsResponseSchema,
+  updateEnvelopeFieldsMeta,
+} from './update-envelope-fields.types';
+
+export const updateEnvelopeFieldsRoute = authenticatedProcedure
+  .meta(updateEnvelopeFieldsMeta)
+  .input(ZUpdateEnvelopeFieldsRequestSchema)
+  .output(ZUpdateEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data: fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const { fields: data } = await updateEnvelopeFields({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+      fields,
+      requestMetadata: ctx.metadata,
+    });
+
+    return {
+      data,
+    };
+  });

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZEnvelopeFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const updateEnvelopeFieldsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/field/update-many',
+    summary: 'Update envelope fields',
+    description: 'Update multiple envelope fields for an envelope',
+    tags: ['Envelope Fields'],
+  },
+};
+
+const ZUpdateFieldSchema = ZEnvelopeFieldAndMetaSchema.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({
+  data: 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,38 @@
+import { createEnvelopeRecipients } from '@documenso/lib/server-only/recipient/create-envelope-recipients';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZCreateEnvelopeRecipientsRequestSchema,
+  ZCreateEnvelopeRecipientsResponseSchema,
+  createEnvelopeRecipientsMeta,
+} from './create-envelope-recipients.types';
+
+export const createEnvelopeRecipientsRoute = authenticatedProcedure
+  .meta(createEnvelopeRecipientsMeta)
+  .input(ZCreateEnvelopeRecipientsRequestSchema)
+  .output(ZCreateEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId, metadata } = ctx;
+    const { envelopeId, data: recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const { recipients: data } = await createEnvelopeRecipients({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: metadata,
+    });
+
+    return {
+      data,
+    };
+  });

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+import { ZEnvelopeRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+import { ZCreateRecipientSchema } from '../../recipient-router/schema';
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const createEnvelopeRecipientsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/recipient/create-many',
+    summary: 'Create envelope recipients',
+    description: 'Create multiple recipients for an envelope',
+    tags: ['Envelope Recipients'],
+  },
+};
+
+export const ZCreateEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZCreateRecipientSchema.array(),
+});
+
+export const ZCreateEnvelopeRecipientsResponseSchema = z.object({
+  data: 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,33 @@
+import { deleteEnvelopeRecipient } from '@documenso/lib/server-only/recipient/delete-envelope-recipient';
+
+import { ZGenericSuccessResponse } from '../../schema';
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeRecipientRequestSchema,
+  ZDeleteEnvelopeRecipientResponseSchema,
+  deleteEnvelopeRecipientMeta,
+} from './delete-envelope-recipient.types';
+
+export const deleteEnvelopeRecipientRoute = authenticatedProcedure
+  .meta(deleteEnvelopeRecipientMeta)
+  .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,
+    });
+
+    return ZGenericSuccessResponse;
+  });

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+import { ZSuccessResponseSchema } from '../../schema';
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const deleteEnvelopeRecipientMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/recipient/delete',
+    summary: 'Delete envelope recipient',
+    description: 'Delete an envelope recipient',
+    tags: ['Envelope Recipients'],
+  },
+};
+
+export const ZDeleteEnvelopeRecipientRequestSchema = z.object({
+  recipientId: z.number(),
+});
+
+export const ZDeleteEnvelopeRecipientResponseSchema = ZSuccessResponseSchema;
+
+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,45 @@
+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,
+  getEnvelopeRecipientMeta,
+} from './get-envelope-recipient.types';
+
+export const getEnvelopeRecipientRoute = authenticatedProcedure
+  .meta(getEnvelopeRecipientMeta)
+  .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,24 @@
+import { z } from 'zod';
+
+import { ZEnvelopeRecipientSchema } from '@documenso/lib/types/recipient';
+
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const getEnvelopeRecipientMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/envelope/recipient/{recipientId}',
+    summary: 'Get envelope recipient',
+    description: 'Returns an envelope recipient given an ID',
+    tags: ['Envelope Recipients'],
+  },
+};
+
+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,38 @@
+import { updateEnvelopeRecipients } from '@documenso/lib/server-only/recipient/update-envelope-recipients';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZUpdateEnvelopeRecipientsRequestSchema,
+  ZUpdateEnvelopeRecipientsResponseSchema,
+  updateEnvelopeRecipientsMeta,
+} from './update-envelope-recipients.types';
+
+export const updateEnvelopeRecipientsRoute = authenticatedProcedure
+  .meta(updateEnvelopeRecipientsMeta)
+  .input(ZUpdateEnvelopeRecipientsRequestSchema)
+  .output(ZUpdateEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data: recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const { recipients: data } = await updateEnvelopeRecipients({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: ctx.metadata,
+    });
+
+    return {
+      data,
+    };
+  });

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+import { ZUpdateRecipientSchema } from '../../recipient-router/schema';
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const updateEnvelopeRecipientsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/recipient/update-many',
+    summary: 'Update envelope recipients',
+    description: 'Update multiple recipients for an envelope',
+    tags: ['Envelope Recipients'],
+  },
+};
+
+export const ZUpdateEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZUpdateRecipientSchema.array(),
+});
+
+export const ZUpdateEnvelopeRecipientsResponseSchema = z.object({
+  data: ZRecipientLiteSchema.array(),
+});
+
+export type TUpdateEnvelopeRecipientsRequest = z.infer<
+  typeof ZUpdateEnvelopeRecipientsRequestSchema
+>;
+export type TUpdateEnvelopeRecipientsResponse = z.infer<
+  typeof ZUpdateEnvelopeRecipientsResponseSchema
+>;

packages/trpc/server/envelope-router/get-envelope-items-by-token.ts

@@ -34,10 +34,25 @@ export const getEnvelopeItemsByTokenRoute = maybeAuthenticatedProcedure
         });
       }
 
-      return await handleGetEnvelopeItemsByUser({ envelopeId, userId: user.id, teamId });
+      const { envelopeItems: data } = await handleGetEnvelopeItemsByUser({
+        envelopeId,
+        userId: user.id,
+        teamId,
+      });
+
+      return {
+        data,
+      };
     }
 
-    return await handleGetEnvelopeItemsByToken({ envelopeId, token: access.token });
+    const { envelopeItems: data } = await handleGetEnvelopeItemsByToken({
+      envelopeId,
+      token: access.token,
+    });
+
+    return {
+      data,
+    };
   });
 
 const handleGetEnvelopeItemsByToken = async ({

packages/trpc/server/envelope-router/get-envelope-items-by-token.types.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 
-import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
 import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
 
 export const ZGetEnvelopeItemsByTokenRequestSchema = z.object({
@@ -17,18 +16,10 @@ export const ZGetEnvelopeItemsByTokenRequestSchema = z.object({
 });
 
 export const ZGetEnvelopeItemsByTokenResponseSchema = z.object({
-  envelopeItems: EnvelopeItemSchema.pick({
+  data: EnvelopeItemSchema.pick({
     id: true,
+    envelopeId: true,
     title: true,
     order: true,
-  })
-    .extend({
-      documentData: DocumentDataSchema.pick({
-        type: true,
-        id: true,
-        data: true,
-        initialData: true,
-      }),
-    })
-    .array(),
+  }).array(),
 });

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

@@ -50,6 +50,6 @@ export const getEnvelopeItemsRoute = authenticatedProcedure
     }
 
     return {
-      envelopeItems: envelope.envelopeItems,
+      data: envelope.envelopeItems,
     };
   });

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

@@ -8,7 +8,7 @@ export const ZGetEnvelopeItemsRequestSchema = z.object({
 });
 
 export const ZGetEnvelopeItemsResponseSchema = z.object({
-  envelopeItems: EnvelopeItemSchema.pick({
+  data: EnvelopeItemSchema.pick({
     id: true,
     title: true,
     order: true,

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

@@ -1,10 +1,14 @@
 import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
 
 import { authenticatedProcedure } from '../trpc';
-import { ZGetEnvelopeRequestSchema, ZGetEnvelopeResponseSchema } from './get-envelope.types';
+import {
+  ZGetEnvelopeRequestSchema,
+  ZGetEnvelopeResponseSchema,
+  getEnvelopeMeta,
+} from './get-envelope.types';
 
 export const getEnvelopeRoute = authenticatedProcedure
-  // .meta(getEnvelopeMeta)
+  .meta(getEnvelopeMeta)
   .input(ZGetEnvelopeRequestSchema)
   .output(ZGetEnvelopeResponseSchema)
   .query(async ({ input, ctx }) => {

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

@@ -2,15 +2,17 @@ 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'],
-//   },
-// };
+import type { TrpcRouteMeta } from '../trpc';
+
+export const getEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'GET',
+    path: '/envelope/{envelopeId}',
+    summary: 'Get envelope',
+    description: 'Returns an envelope given an ID',
+    tags: ['Envelope'],
+  },
+};
 
 export const ZGetEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),

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

@@ -1,13 +1,15 @@
 import { resendDocument } from '@documenso/lib/server-only/document/resend-document';
+import { formatSigningLink } from '@documenso/lib/utils/recipients';
 
 import { authenticatedProcedure } from '../trpc';
 import {
   ZRedistributeEnvelopeRequestSchema,
   ZRedistributeEnvelopeResponseSchema,
+  redistributeEnvelopeMeta,
 } from './redistribute-envelope.types';
 
 export const redistributeEnvelopeRoute = authenticatedProcedure
-  // .meta(redistributeEnvelopeMeta)
+  .meta(redistributeEnvelopeMeta)
   .input(ZRedistributeEnvelopeRequestSchema)
   .output(ZRedistributeEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -21,7 +23,7 @@ export const redistributeEnvelopeRoute = authenticatedProcedure
       },
     });
 
-    await resendDocument({
+    const envelope = await resendDocument({
       userId: ctx.user.id,
       teamId,
       id: {
@@ -31,4 +33,18 @@ export const redistributeEnvelopeRoute = authenticatedProcedure
       recipients,
       requestMetadata: ctx.metadata,
     });
+
+    return {
+      success: true,
+      id: envelope.id,
+      recipients: envelope.recipients.map((recipient) => ({
+        id: recipient.id,
+        name: recipient.name,
+        email: recipient.email,
+        token: recipient.token,
+        role: recipient.role,
+        signingOrder: recipient.signingOrder,
+        signingUrl: formatSigningLink(recipient.token),
+      })),
+    };
   });

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

@@ -1,15 +1,19 @@
 import { z } from 'zod';
 
-// export const redistributeEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/redistribute',
-//     summary: 'Redistribute document',
-//     description:
-//       'Redistribute the document to the provided recipients who have not actioned the document. Will use the distribution method set in the document',
-//     tags: ['Envelope'],
-//   },
-// };
+import { ZSuccessResponseSchema } from '../schema';
+import type { TrpcRouteMeta } from '../trpc';
+import { ZRecipientWithSigningUrlSchema } from './schema';
+
+export const redistributeEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/redistribute',
+    summary: 'Redistribute envelope',
+    description:
+      'Redistribute the envelope to the provided recipients who have not actioned the envelope. Will use the distribution method set in the envelope',
+    tags: ['Envelope'],
+  },
+};
 
 export const ZRedistributeEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),
@@ -19,7 +23,10 @@ export const ZRedistributeEnvelopeRequestSchema = z.object({
     .describe('The IDs of the recipients to redistribute the envelope to.'),
 });
 
-export const ZRedistributeEnvelopeResponseSchema = z.void();
+export const ZRedistributeEnvelopeResponseSchema = ZSuccessResponseSchema.extend({
+  id: z.string().describe('The ID of the envelope that was redistributed.'),
+  recipients: ZRecipientWithSigningUrlSchema.array(),
+});
 
 export type TRedistributeEnvelopeRequest = z.infer<typeof ZRedistributeEnvelopeRequestSchema>;
 export type TRedistributeEnvelopeResponse = z.infer<typeof ZRedistributeEnvelopeResponseSchema>;

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

@@ -8,7 +8,16 @@ import { createEnvelopeItemsRoute } from './create-envelope-items';
 import { deleteEnvelopeRoute } from './delete-envelope';
 import { deleteEnvelopeItemRoute } from './delete-envelope-item';
 import { distributeEnvelopeRoute } from './distribute-envelope';
+import { downloadEnvelopeItemRoute } from './download-envelope-item';
 import { duplicateEnvelopeRoute } from './duplicate-envelope';
+import { createEnvelopeFieldsRoute } from './envelope-fields/create-envelope-fields';
+import { deleteEnvelopeFieldRoute } from './envelope-fields/delete-envelope-field';
+import { getEnvelopeFieldRoute } from './envelope-fields/get-envelope-field';
+import { updateEnvelopeFieldsRoute } from './envelope-fields/update-envelope-fields';
+import { createEnvelopeRecipientsRoute } from './envelope-recipients/create-envelope-recipients';
+import { deleteEnvelopeRecipientRoute } from './envelope-recipients/delete-envelope-recipient';
+import { getEnvelopeRecipientRoute } from './envelope-recipients/get-envelope-recipient';
+import { updateEnvelopeRecipientsRoute } from './envelope-recipients/update-envelope-recipients';
 import { getEnvelopeRoute } from './get-envelope';
 import { getEnvelopeItemsRoute } from './get-envelope-items';
 import { getEnvelopeItemsByTokenRoute } from './get-envelope-items-by-token';
@@ -16,37 +25,53 @@ import { redistributeEnvelopeRoute } from './redistribute-envelope';
 import { setEnvelopeFieldsRoute } from './set-envelope-fields';
 import { setEnvelopeRecipientsRoute } from './set-envelope-recipients';
 import { signEnvelopeFieldRoute } from './sign-envelope-field';
+import { signingStatusEnvelopeRoute } from './signing-status-envelope';
 import { updateEnvelopeRoute } from './update-envelope';
 import { updateEnvelopeItemsRoute } from './update-envelope-items';
+import { useEnvelopeRoute } from './use-envelope';
 
+/**
+ * Note: The order of the routes is important for public API routes.
+ *
+ * Example: GET /envelope/attachment must appear before GET /envelope/:id
+ */
 export const envelopeRouter = router({
-  get: getEnvelopeRoute,
-  create: createEnvelopeRoute,
-  update: updateEnvelopeRoute,
-  delete: deleteEnvelopeRoute,
-  duplicate: duplicateEnvelopeRoute,
-  distribute: distributeEnvelopeRoute,
-  redistribute: redistributeEnvelopeRoute,
-  // share: shareEnvelopeRoute,
-
-  item: {
-    getMany: getEnvelopeItemsRoute,
-    getManyByToken: getEnvelopeItemsByTokenRoute,
-    createMany: createEnvelopeItemsRoute,
-    updateMany: updateEnvelopeItemsRoute,
-    delete: deleteEnvelopeItemRoute,
-  },
-  recipient: {
-    set: setEnvelopeRecipientsRoute,
-  },
-  field: {
-    set: setEnvelopeFieldsRoute,
-    sign: signEnvelopeFieldRoute,
-  },
   attachment: {
     find: findAttachmentsRoute,
     create: createAttachmentRoute,
     update: updateAttachmentRoute,
     delete: deleteAttachmentRoute,
   },
+  item: {
+    getMany: getEnvelopeItemsRoute,
+    getManyByToken: getEnvelopeItemsByTokenRoute,
+    createMany: createEnvelopeItemsRoute,
+    updateMany: updateEnvelopeItemsRoute,
+    delete: deleteEnvelopeItemRoute,
+    download: downloadEnvelopeItemRoute,
+  },
+  recipient: {
+    get: getEnvelopeRecipientRoute,
+    createMany: createEnvelopeRecipientsRoute,
+    updateMany: updateEnvelopeRecipientsRoute,
+    delete: deleteEnvelopeRecipientRoute,
+    set: setEnvelopeRecipientsRoute,
+  },
+  field: {
+    get: getEnvelopeFieldRoute,
+    createMany: createEnvelopeFieldsRoute,
+    updateMany: updateEnvelopeFieldsRoute,
+    delete: deleteEnvelopeFieldRoute,
+    set: setEnvelopeFieldsRoute,
+    sign: signEnvelopeFieldRoute,
+  },
+  get: getEnvelopeRoute,
+  create: createEnvelopeRoute,
+  use: useEnvelopeRoute,
+  update: updateEnvelopeRoute,
+  delete: deleteEnvelopeRoute,
+  duplicate: duplicateEnvelopeRoute,
+  distribute: distributeEnvelopeRoute,
+  redistribute: redistributeEnvelopeRoute,
+  signingStatus: signingStatusEnvelopeRoute,
 });

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+import RecipientSchema from '@documenso/prisma/generated/zod/modelSchema/RecipientSchema';
+
+// Common schemas between envelope routes.
+
+export const ZRecipientWithSigningUrlSchema = RecipientSchema.pick({
+  id: true,
+  name: true,
+  email: true,
+  token: true,
+  role: true,
+  signingOrder: true,
+}).extend({
+  signingUrl: z.string().describe('The URL which the recipient uses to sign the document.'),
+});

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

@@ -65,7 +65,7 @@ export const setEnvelopeFieldsRoute = authenticatedProcedure
       .exhaustive();
 
     return {
-      fields: result.fields.map((field) => ({
+      data: result.fields.map((field) => ({
         id: field.id,
         formId: field.formId,
       })),

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

@@ -1,12 +1,19 @@
 import { EnvelopeType, FieldType } from '@prisma/client';
 import { z } from 'zod';
 
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+} from '@documenso/lib/types/field';
 import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
 
 export const ZSetEnvelopeFieldsRequestSchema = z.object({
   envelopeId: z.string(),
   envelopeType: z.nativeEnum(EnvelopeType),
   fields: z.array(
+    // Todo: Envelopes - Use strict schema for types + field meta.
     z.object({
       id: z
         .number()
@@ -20,34 +27,17 @@ export const ZSetEnvelopeFieldsRequestSchema = z.object({
         .number()
         .min(1)
         .describe('The page number of the field on the envelope. Starts from 1.'),
-      // Todo: Envelopes - Extract these 0-100 schemas with better descriptions.
-      positionX: z
-        .number()
-        .min(0)
-        .max(100)
-        .describe('The percentage based X position of the field on the envelope.'),
-      positionY: z
-        .number()
-        .min(0)
-        .max(100)
-        .describe('The percentage based Y position of the field on the envelope.'),
-      width: z
-        .number()
-        .min(0)
-        .max(100)
-        .describe('The percentage based width of the field on the envelope.'),
-      height: z
-        .number()
-        .min(0)
-        .max(100)
-        .describe('The percentage based height of the field on the envelope.'),
-      fieldMeta: ZFieldMetaSchema, // Todo: Envelopes - Use a more strict form?
+      positionX: ZClampedFieldPositionXSchema,
+      positionY: ZClampedFieldPositionYSchema,
+      width: ZClampedFieldWidthSchema,
+      height: ZClampedFieldHeightSchema,
+      fieldMeta: ZFieldMetaSchema,
     }),
   ),
 });
 
 export const ZSetEnvelopeFieldsResponseSchema = z.object({
-  fields: z
+  data: z
     .object({
       id: z.number(),
       formId: z.string().optional(),

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

@@ -23,7 +23,7 @@ export const setEnvelopeRecipientsRoute = authenticatedProcedure
       },
     });
 
-    return await match(envelopeType)
+    const { recipients: data } = await match(envelopeType)
       .with(EnvelopeType.DOCUMENT, async () =>
         setDocumentRecipients({
           userId: ctx.user.id,
@@ -48,4 +48,8 @@ export const setEnvelopeRecipientsRoute = authenticatedProcedure
         }),
       )
       .exhaustive();
+
+    return {
+      data,
+    };
   });

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

@@ -20,7 +20,7 @@ export const ZSetEnvelopeRecipientsRequestSchema = z.object({
 });
 
 export const ZSetEnvelopeRecipientsResponseSchema = z.object({
-  recipients: ZRecipientLiteSchema.omit({
+  data: ZRecipientLiteSchema.omit({
     documentId: true,
     templateId: true,
   }).array(),

packages/trpc/server/envelope-router/sign-envelope-field.ts

@@ -133,6 +133,49 @@ export const signEnvelopeFieldRoute = procedure
 
     const insertionValues = extractFieldInsertionValues({ fieldValue, field, documentMeta });
 
+    // Early return for uninserting fields.
+    if (!insertionValues.inserted) {
+      return await prisma.$transaction(async (tx) => {
+        const updatedField = await tx.field.update({
+          where: {
+            id: field.id,
+          },
+          data: {
+            customText: '',
+            inserted: false,
+          },
+        });
+
+        await tx.signature.deleteMany({
+          where: {
+            fieldId: field.id,
+          },
+        });
+
+        if (recipient.role !== RecipientRole.ASSISTANT) {
+          await tx.documentAuditLog.create({
+            data: createDocumentAuditLogData({
+              type: DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_FIELD_UNINSERTED,
+              envelopeId: envelope.id,
+              user: {
+                name: recipient.name,
+                email: recipient.email,
+              },
+              requestMetadata: metadata.requestMetadata,
+              data: {
+                field: field.type,
+                fieldId: field.secondaryId,
+              },
+            }),
+          });
+        }
+
+        return {
+          signedField: updatedField,
+        };
+      });
+    }
+
     const derivedRecipientActionAuth = await validateFieldAuth({
       documentAuthOptions: envelope.authOptions,
       recipient,

packages/trpc/server/envelope-router/sign-envelope-field.types.ts

@@ -16,7 +16,7 @@ export const ZSignEnvelopeFieldValue = z.discriminatedUnion('type', [
   }),
   z.object({
     type: z.literal(FieldType.NUMBER),
-    value: z.number().nullable(),
+    value: z.string().nullable(),
   }),
   z.object({
     type: z.literal(FieldType.EMAIL),

packages/trpc/server/envelope-router/signing-status-envelope.ts

@@ -0,0 +1,82 @@
+import { DocumentStatus, EnvelopeType, RecipientRole, SigningStatus } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { prisma } from '@documenso/prisma';
+
+import { maybeAuthenticatedProcedure } from '../trpc';
+import {
+  ZSigningStatusEnvelopeRequestSchema,
+  ZSigningStatusEnvelopeResponseSchema,
+} from './signing-status-envelope.types';
+
+// Internal route - not intended for public API usage
+export const signingStatusEnvelopeRoute = maybeAuthenticatedProcedure
+  .input(ZSigningStatusEnvelopeRequestSchema)
+  .output(ZSigningStatusEnvelopeResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { token } = input;
+
+    ctx.logger.info({
+      input: {
+        token,
+      },
+    });
+
+    const envelope = await prisma.envelope.findFirst({
+      where: {
+        type: EnvelopeType.DOCUMENT,
+        recipients: {
+          some: {
+            token,
+          },
+        },
+      },
+      include: {
+        recipients: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+            signingStatus: true,
+            role: true,
+          },
+        },
+      },
+    });
+
+    if (!envelope) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Envelope not found',
+      });
+    }
+
+    // Check if envelope is rejected
+    if (envelope.status === DocumentStatus.REJECTED) {
+      return {
+        status: 'REJECTED',
+      };
+    }
+
+    if (envelope.status === DocumentStatus.COMPLETED) {
+      return {
+        status: 'COMPLETED',
+      };
+    }
+
+    const isComplete =
+      envelope.recipients.some((recipient) => recipient.signingStatus === SigningStatus.REJECTED) ||
+      envelope.recipients.every(
+        (recipient) =>
+          recipient.role === RecipientRole.CC || recipient.signingStatus === SigningStatus.SIGNED,
+      );
+
+    if (isComplete) {
+      return {
+        status: 'PROCESSING',
+      };
+    }
+
+    return {
+      status: 'PENDING',
+    };
+  });

packages/trpc/server/envelope-router/signing-status-envelope.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const EnvelopeSigningStatus = z.enum(['PENDING', 'PROCESSING', 'COMPLETED', 'REJECTED']);
+
+export const ZSigningStatusEnvelopeRequestSchema = z.object({
+  token: z.string().describe('The recipient token to check the signing status for'),
+});
+
+export const ZSigningStatusEnvelopeResponseSchema = z.object({
+  status: EnvelopeSigningStatus.describe('The current signing status of the envelope'),
+});
+
+export type TSigningStatusEnvelopeRequest = z.infer<typeof ZSigningStatusEnvelopeRequestSchema>;
+export type TSigningStatusEnvelopeResponse = z.infer<typeof ZSigningStatusEnvelopeResponseSchema>;

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

@@ -7,9 +7,11 @@ import { authenticatedProcedure } from '../trpc';
 import {
   ZUpdateEnvelopeItemsRequestSchema,
   ZUpdateEnvelopeItemsResponseSchema,
+  updateEnvelopeItemsMeta,
 } from './update-envelope-items.types';
 
 export const updateEnvelopeItemsRoute = authenticatedProcedure
+  .meta(updateEnvelopeItemsMeta)
   .input(ZUpdateEnvelopeItemsRequestSchema)
   .output(ZUpdateEnvelopeItemsResponseSchema)
   .mutation(async ({ input, ctx }) => {
@@ -93,6 +95,6 @@ export const updateEnvelopeItemsRoute = authenticatedProcedure
     // Todo: Envelope [AUDIT_LOGS]
 
     return {
-      updatedEnvelopeItems,
+      data: updatedEnvelopeItems,
     };
   });

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

@@ -3,6 +3,17 @@ import { z } from 'zod';
 import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
 
 import { ZDocumentTitleSchema } from '../document-router/schema';
+import type { TrpcRouteMeta } from '../trpc';
+
+export const updateEnvelopeItemsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/item/update-many',
+    summary: 'Update envelope items',
+    description: 'Update multiple envelope items for an envelope',
+    tags: ['Envelope Items'],
+  },
+};
 
 export const ZUpdateEnvelopeItemsRequestSchema = z.object({
   envelopeId: z.string(),
@@ -17,7 +28,7 @@ export const ZUpdateEnvelopeItemsRequestSchema = z.object({
 });
 
 export const ZUpdateEnvelopeItemsResponseSchema = z.object({
-  updatedEnvelopeItems: EnvelopeItemSchema.pick({
+  data: EnvelopeItemSchema.pick({
     id: true,
     order: true,
     title: true,

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

@@ -4,10 +4,11 @@ import { authenticatedProcedure } from '../trpc';
 import {
   ZUpdateEnvelopeRequestSchema,
   ZUpdateEnvelopeResponseSchema,
+  updateEnvelopeMeta,
 } from './update-envelope.types';
 
 export const updateEnvelopeRoute = authenticatedProcedure
-  // .meta(updateEnvelopeTrpcMeta)
+  .meta(updateEnvelopeMeta)
   .input(ZUpdateEnvelopeRequestSchema)
   .output(ZUpdateEnvelopeResponseSchema)
   .mutation(async ({ input, ctx }) => {

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

@@ -1,5 +1,3 @@
-import { EnvelopeType } from '@prisma/client';
-// import type { OpenApiMeta } from 'trpc-to-openapi';
 import { z } from 'zod';
 
 import {
@@ -14,19 +12,19 @@ import {
   ZDocumentTitleSchema,
   ZDocumentVisibilitySchema,
 } from '../document-router/schema';
+import type { TrpcRouteMeta } from '../trpc';
 
-// export const updateEnvelopeMeta: TrpcRouteMeta = {
-//   openapi: {
-//     method: 'POST',
-//     path: '/envelope/update',
-//     summary: 'Update envelope',
-//     tags: ['Envelope'],
-//   },
-// };
+export const updateEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/update',
+    summary: 'Update envelope',
+    tags: ['Envelope'],
+  },
+};
 
 export const ZUpdateEnvelopeRequestSchema = z.object({
   envelopeId: z.string(),
-  envelopeType: z.nativeEnum(EnvelopeType),
   data: z
     .object({
       title: ZDocumentTitleSchema.optional(),

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

@@ -0,0 +1,180 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { getServerLimits } from '@documenso/ee/server-only/limits/server';
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { sendDocument } from '@documenso/lib/server-only/document/send-document';
+import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
+import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
+import { formatSigningLink } from '@documenso/lib/utils/recipients';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZUseEnvelopeRequestSchema,
+  ZUseEnvelopeResponseSchema,
+  useEnvelopeMeta,
+} from './use-envelope.types';
+
+export const useEnvelopeRoute = authenticatedProcedure
+  .meta(useEnvelopeMeta)
+  .input(ZUseEnvelopeRequestSchema)
+  .output(ZUseEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+
+    const { payload, files = [] } = input;
+
+    const {
+      envelopeId,
+      externalId,
+      recipients = [],
+      distributeDocument,
+      customDocumentData = [],
+      folderId,
+      prefillFields,
+      override,
+      attachments,
+    } = payload;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+        folderId,
+      },
+    });
+
+    const limits = await getServerLimits({ userId: user.id, teamId });
+
+    if (limits.remaining.documents === 0) {
+      throw new AppError(AppErrorCode.LIMIT_EXCEEDED, {
+        message: 'You have reached your document limit.',
+      });
+    }
+
+    // Verify the template exists and get envelope items
+    const envelope = await getEnvelopeById({
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: EnvelopeType.TEMPLATE,
+      userId: user.id,
+      teamId,
+    });
+
+    if (files.length > envelope.envelopeItems.length) {
+      throw new AppError(AppErrorCode.INVALID_BODY, {
+        message: `You cannot upload more than ${envelope.envelopeItems.length} envelope items per envelope`,
+      });
+    }
+
+    const filesToUpload = files.filter(
+      (file, index) =>
+        payload.customDocumentData &&
+        payload.customDocumentData.some(
+          (mapping) => mapping.identifier === file.name || mapping.identifier === index,
+        ),
+    );
+
+    // Process uploaded files and create document data for them
+    const uploadedFiles = await Promise.all(
+      filesToUpload.map(async (file) => {
+        const { id: documentDataId } = await putNormalizedPdfFileServerSide(file);
+
+        return {
+          name: file.name,
+          documentDataId,
+        };
+      }),
+    );
+
+    // Map custom document data using identifiers
+    const customDocumentDataMapped = customDocumentData?.map((mapping) => {
+      let documentDataId: string | undefined;
+
+      // Find the uploaded file by identifier
+      if (typeof mapping.identifier === 'string') {
+        documentDataId = uploadedFiles.find(
+          (file) => file.name === mapping.identifier,
+        )?.documentDataId;
+      }
+
+      if (typeof mapping.identifier === 'number') {
+        documentDataId = uploadedFiles.at(mapping.identifier)?.documentDataId;
+      }
+
+      if (mapping.identifier === undefined) {
+        documentDataId = uploadedFiles.at(0)?.documentDataId;
+      }
+
+      if (!documentDataId) {
+        throw new AppError(AppErrorCode.NOT_FOUND, {
+          message: `File with identifier "${mapping.identifier}" not found in uploaded files`,
+        });
+      }
+
+      // Verify that the envelopeItemId exists in the template
+      const envelopeItem = envelope.envelopeItems.find(
+        (item) => item.id === mapping.envelopeItemId,
+      );
+
+      if (!envelopeItem) {
+        throw new AppError(AppErrorCode.NOT_FOUND, {
+          message: `Envelope item with ID "${mapping.envelopeItemId}" not found in template`,
+        });
+      }
+
+      return {
+        documentDataId,
+        envelopeItemId: mapping.envelopeItemId,
+      };
+    });
+
+    // Create document from template
+    const createdEnvelope = await createDocumentFromTemplate({
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      externalId,
+      teamId,
+      userId: user.id,
+      recipients,
+      customDocumentData: customDocumentDataMapped,
+      requestMetadata: ctx.metadata,
+      folderId,
+      prefillFields,
+      override,
+      attachments,
+    });
+
+    // Distribute document if requested
+    if (distributeDocument) {
+      await sendDocument({
+        id: {
+          type: 'envelopeId',
+          id: createdEnvelope.id,
+        },
+        userId: user.id,
+        teamId,
+        requestMetadata: ctx.metadata,
+      }).catch((err) => {
+        console.error(err);
+
+        throw new AppError('DOCUMENT_SEND_FAILED');
+      });
+    }
+
+    return {
+      id: createdEnvelope.id,
+      recipients: createdEnvelope.recipients.map((recipient) => ({
+        id: recipient.id,
+        name: recipient.name,
+        email: recipient.email,
+        token: recipient.token,
+        role: recipient.role,
+        signingOrder: recipient.signingOrder,
+        signingUrl: formatSigningLink(recipient.token),
+      })),
+    };
+  });

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

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { zfd } from 'zod-form-data';
+
+import { ZDocumentEmailSettingsSchema } from '@documenso/lib/types/document-email';
+import {
+  ZDocumentMetaDateFormatSchema,
+  ZDocumentMetaDistributionMethodSchema,
+  ZDocumentMetaDrawSignatureEnabledSchema,
+  ZDocumentMetaLanguageSchema,
+  ZDocumentMetaMessageSchema,
+  ZDocumentMetaRedirectUrlSchema,
+  ZDocumentMetaSubjectSchema,
+  ZDocumentMetaTimezoneSchema,
+  ZDocumentMetaTypedSignatureEnabledSchema,
+  ZDocumentMetaUploadSignatureEnabledSchema,
+} from '@documenso/lib/types/document-meta';
+import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
+import { ZFieldMetaPrefillFieldsSchema } from '@documenso/lib/types/field-meta';
+
+import { zodFormData } from '../../utils/zod-form-data';
+import type { TrpcRouteMeta } from '../trpc';
+import { ZRecipientWithSigningUrlSchema } from './schema';
+
+export const useEnvelopeMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/use',
+    contentTypes: ['multipart/form-data'],
+    summary: 'Use envelope',
+    description:
+      'Create a document envelope from a template envelope. Upload custom files to replace the template PDFs and map them to specific envelope items using identifiers.',
+    tags: ['Envelope'],
+  },
+};
+
+export const ZUseEnvelopePayloadSchema = z.object({
+  envelopeId: z.string().describe('The ID of the template envelope to use.'),
+  externalId: z.string().optional().describe('External ID for the created document.'),
+  recipients: z
+    .array(
+      z.object({
+        id: z.number().describe('The ID of the recipient in the template.'),
+        email: z.string().email().max(254),
+        name: z.string().max(255).optional(),
+        signingOrder: z.number().optional(),
+      }),
+    )
+    .describe('The information of the recipients to create the document with.')
+    .optional(),
+  distributeDocument: z
+    .boolean()
+    .describe('Whether to create the document as pending and distribute it to recipients.')
+    .optional(),
+  customDocumentData: z
+    .array(
+      z.object({
+        identifier: z
+          .union([z.string(), z.number()])
+          .describe(
+            'Either the filename or the index of the file that was uploaded. This maps to which envelope item in the template should use this file.',
+          ),
+        envelopeItemId: z
+          .string()
+          .describe('The envelope item ID from the template to replace with the uploaded file.'),
+      }),
+    )
+    .describe(
+      'Map uploaded files to specific envelope items in the template. If not provided, files will be ignored.',
+    )
+    .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(),
+  prefillFields: z
+    .array(ZFieldMetaPrefillFieldsSchema)
+    .describe(
+      'The fields to prefill on the document before sending it out. Useful when you want to create a document from an existing template and pre-fill the fields with specific values.',
+    )
+    .optional(),
+  override: z
+    .object({
+      title: z.string().min(1).max(255).optional(),
+      subject: ZDocumentMetaSubjectSchema.optional(),
+      message: ZDocumentMetaMessageSchema.optional(),
+      timezone: ZDocumentMetaTimezoneSchema.optional(),
+      dateFormat: ZDocumentMetaDateFormatSchema.optional(),
+      redirectUrl: ZDocumentMetaRedirectUrlSchema.optional(),
+      distributionMethod: ZDocumentMetaDistributionMethodSchema.optional(),
+      emailSettings: ZDocumentEmailSettingsSchema.optional(),
+      language: ZDocumentMetaLanguageSchema.optional(),
+      typedSignatureEnabled: ZDocumentMetaTypedSignatureEnabledSchema.optional(),
+      uploadSignatureEnabled: ZDocumentMetaUploadSignatureEnabledSchema.optional(),
+      drawSignatureEnabled: ZDocumentMetaDrawSignatureEnabledSchema.optional(),
+      allowDictateNextSigner: z.boolean().optional(),
+    })
+    .describe('Override values from the template for the created document.')
+    .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(),
+});
+
+export const ZUseEnvelopeRequestSchema = zodFormData({
+  payload: zfd.json(ZUseEnvelopePayloadSchema),
+  files: zfd.repeatableOfType(zfd.file()).optional(),
+});
+
+export const ZUseEnvelopeResponseSchema = z.object({
+  id: z.string().describe('The ID of the created envelope.'),
+  recipients: ZRecipientWithSigningUrlSchema.array(),
+});
+
+export type TUseEnvelopePayload = z.infer<typeof ZUseEnvelopePayloadSchema>;
+export type TUseEnvelopeRequest = z.infer<typeof ZUseEnvelopeRequestSchema>;
+export type TUseEnvelopeResponse = z.infer<typeof ZUseEnvelopeResponseSchema>;

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

@@ -8,10 +8,9 @@ import { removeSignedFieldWithToken } from '@documenso/lib/server-only/field/rem
 import { setFieldsForDocument } from '@documenso/lib/server-only/field/set-fields-for-document';
 import { setFieldsForTemplate } from '@documenso/lib/server-only/field/set-fields-for-template';
 import { signFieldWithToken } from '@documenso/lib/server-only/field/sign-field-with-token';
-import { updateDocumentFields } from '@documenso/lib/server-only/field/update-document-fields';
-import { updateTemplateFields } from '@documenso/lib/server-only/field/update-template-fields';
+import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
 
-import { ZGenericSuccessResponse, ZSuccessResponseSchema } from '../document-router/schema';
+import { ZGenericSuccessResponse, ZSuccessResponseSchema } from '../schema';
 import { authenticatedProcedure, procedure, router } from '../trpc';
 import {
   ZCreateDocumentFieldRequestSchema,
@@ -109,7 +108,14 @@ export const fieldRouter = router({
           type: 'documentId',
           id: documentId,
         },
-        fields: [field],
+        fields: [
+          {
+            ...field,
+            page: field.pageNumber,
+            positionX: field.pageX,
+            positionY: field.pageY,
+          },
+        ],
         requestMetadata: ctx.metadata,
       });
 
@@ -148,7 +154,12 @@ export const fieldRouter = router({
           type: 'documentId',
           id: documentId,
         },
-        fields,
+        fields: fields.map((field) => ({
+          ...field,
+          page: field.pageNumber,
+          positionX: field.pageX,
+          positionY: field.pageY,
+        })),
         requestMetadata: ctx.metadata,
       });
     }),
@@ -178,10 +189,14 @@ export const fieldRouter = router({
         },
       });
 
-      const updatedFields = await updateDocumentFields({
+      const updatedFields = await updateEnvelopeFields({
         userId: ctx.user.id,
         teamId,
-        documentId,
+        id: {
+          type: 'documentId',
+          id: documentId,
+        },
+        type: EnvelopeType.DOCUMENT,
         fields: [field],
         requestMetadata: ctx.metadata,
       });
@@ -214,10 +229,14 @@ export const fieldRouter = router({
         },
       });
 
-      return await updateDocumentFields({
+      return await updateEnvelopeFields({
         userId: ctx.user.id,
         teamId,
-        documentId,
+        id: {
+          type: 'documentId',
+          id: documentId,
+        },
+        type: EnvelopeType.DOCUMENT,
         fields,
         requestMetadata: ctx.metadata,
       });
@@ -328,7 +347,14 @@ export const fieldRouter = router({
           type: 'templateId',
           id: templateId,
         },
-        fields: [field],
+        fields: [
+          {
+            ...field,
+            page: field.pageNumber,
+            positionX: field.pageX,
+            positionY: field.pageY,
+          },
+        ],
         requestMetadata: ctx.metadata,
       });
 
@@ -401,7 +427,12 @@ export const fieldRouter = router({
           type: 'templateId',
           id: templateId,
         },
-        fields,
+        fields: fields.map((field) => ({
+          ...field,
+          page: field.pageNumber,
+          positionX: field.pageX,
+          positionY: field.pageY,
+        })),
         requestMetadata: ctx.metadata,
       });
     }),
@@ -431,11 +462,16 @@ export const fieldRouter = router({
         },
       });
 
-      const updatedFields = await updateTemplateFields({
+      const updatedFields = await updateEnvelopeFields({
         userId: ctx.user.id,
         teamId,
-        templateId,
+        id: {
+          type: 'templateId',
+          id: templateId,
+        },
+        type: EnvelopeType.TEMPLATE,
         fields: [field],
+        requestMetadata: ctx.metadata,
       });
 
       return updatedFields.fields[0];
@@ -466,11 +502,16 @@ export const fieldRouter = router({
         },
       });
 
-      return await updateTemplateFields({
+      return await updateEnvelopeFields({
         userId: ctx.user.id,
         teamId,
-        templateId,
+        id: {
+          type: 'templateId',
+          id: templateId,
+        },
+        type: EnvelopeType.TEMPLATE,
         fields,
+        requestMetadata: ctx.metadata,
       });
     }),
 

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

@@ -7,6 +7,7 @@ import { getFolderBreadcrumbs } from '@documenso/lib/server-only/folder/get-fold
 import { getFolderById } from '@documenso/lib/server-only/folder/get-folder-by-id';
 import { updateFolder } from '@documenso/lib/server-only/folder/update-folder';
 
+import { ZGenericSuccessResponse, ZSuccessResponseSchema } from '../schema';
 import { authenticatedProcedure, router } from '../trpc';
 import {
   ZCreateFolderRequestSchema,
@@ -16,10 +17,8 @@ import {
   ZFindFoldersInternalResponseSchema,
   ZFindFoldersRequestSchema,
   ZFindFoldersResponseSchema,
-  ZGenericSuccessResponse,
   ZGetFoldersResponseSchema,
   ZGetFoldersSchema,
-  ZSuccessResponseSchema,
   ZUpdateFolderRequestSchema,
   ZUpdateFolderResponseSchema,
 } from './schema';

packages/trpc/server/folder-router/schema.ts

@@ -5,19 +5,6 @@ import { ZFindResultResponse, ZFindSearchParamsSchema } from '@documenso/lib/typ
 import { DocumentVisibility } from '@documenso/prisma/generated/types';
 import FolderSchema from '@documenso/prisma/generated/zod/modelSchema/FolderSchema';
 
-/**
- * Required for empty responses since we currently can't 201 requests for our openapi setup.
- *
- * Without this it will throw an error in Speakeasy SDK when it tries to parse an empty response.
- */
-export const ZSuccessResponseSchema = z.object({
-  success: z.boolean(),
-});
-
-export const ZGenericSuccessResponse = {
-  success: true,
-} satisfies z.infer<typeof ZSuccessResponseSchema>;
-
 export const ZFolderSchema = FolderSchema.pick({
   id: true,
   name: true,