feat: add envelopes (#2025)

This PR is handles the changes required to support envelopes. The new
envelope editor/signing page will be hidden during release.

The core changes here is to migrate the documents and templates model to
a centralized envelopes model.

Even though Documents and Templates are removed, from the user
perspective they will still exist as we remap envelopes to documents and
templates.

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

@@ -0,0 +1,111 @@
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { prefixedId } from '@documenso/lib/universal/id';
+import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZCreateEnvelopeItemsRequestSchema,
+  ZCreateEnvelopeItemsResponseSchema,
+} from './create-envelope-items.types';
+
+export const createEnvelopeItemsRoute = authenticatedProcedure
+  .input(ZCreateEnvelopeItemsRequestSchema)
+  .output(ZCreateEnvelopeItemsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, items } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    // Todo: Envelopes - What to do about "normalizing"?
+    const { envelopeWhereInput } = await getEnvelopeWhereInput({
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+      userId: user.id,
+      teamId,
+    });
+
+    const envelope = await prisma.envelope.findUnique({
+      where: envelopeWhereInput,
+      include: {
+        recipients: true,
+        envelopeItems: {
+          orderBy: {
+            order: 'asc',
+          },
+        },
+      },
+    });
+
+    if (!envelope) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Envelope not found',
+      });
+    }
+
+    if (!canEnvelopeItemsBeModified(envelope, envelope.recipients)) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope item is not editable',
+      });
+    }
+
+    // Todo: Envelopes - Limit amount of items that can be created.
+
+    const foundDocumentData = await prisma.documentData.findMany({
+      where: {
+        id: {
+          in: items.map((item) => item.documentDataId),
+        },
+      },
+      select: {
+        envelopeItem: {
+          select: {
+            id: true,
+          },
+        },
+      },
+    });
+
+    // 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',
+      });
+    }
+
+    const currentHighestOrderValue =
+      envelope.envelopeItems[envelope.envelopeItems.length - 1]?.order ?? 1;
+
+    const result = await prisma.envelopeItem.createManyAndReturn({
+      data: items.map((item, index) => ({
+        id: prefixedId('envelope_item'),
+        envelopeId,
+        title: item.title,
+        documentDataId: item.documentDataId,
+        order: currentHighestOrderValue + 1,
+      })),
+      include: {
+        documentData: true,
+      },
+    });
+
+    return {
+      createdEnvelopeItems: result,
+    };
+  });

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
+import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
+
+import { ZDocumentTitleSchema } from '../document-router/schema';
+
+export const ZCreateEnvelopeItemsRequestSchema = z.object({
+  envelopeId: z.string(),
+  items: z
+    .object({
+      title: ZDocumentTitleSchema,
+      documentDataId: z.string(),
+    })
+    .array(),
+});
+
+export const ZCreateEnvelopeItemsResponseSchema = z.object({
+  createdEnvelopeItems: 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(),
+});
+
+export type TCreateEnvelopeItemsRequest = z.infer<typeof ZCreateEnvelopeItemsRequestSchema>;
+export type TCreateEnvelopeItemsResponse = z.infer<typeof ZCreateEnvelopeItemsResponseSchema>;

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

@@ -0,0 +1,68 @@
+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 { authenticatedProcedure } from '../trpc';
+import {
+  ZCreateEnvelopeRequestSchema,
+  ZCreateEnvelopeResponseSchema,
+} from './create-envelope.types';
+
+export const createEnvelopeRoute = authenticatedProcedure
+  .input(ZCreateEnvelopeRequestSchema) // Note: Before releasing this to public, update the response schema to be correct.
+  .output(ZCreateEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const {
+      title,
+      type,
+      externalId,
+      visibility,
+      globalAccessAuth,
+      globalActionAuth,
+      recipients,
+      folderId,
+      items,
+      meta,
+    } = input;
+
+    ctx.logger.info({
+      input: {
+        folderId,
+      },
+    });
+
+    // Todo: Envelopes - Put the claims for number of items into this.
+    const { remaining } = await getServerLimits({ userId: user.id, teamId });
+
+    if (remaining.documents <= 0) {
+      throw new AppError(AppErrorCode.LIMIT_EXCEEDED, {
+        message: 'You have reached your document limit for this month. Please upgrade your plan.',
+        statusCode: 400,
+      });
+    }
+
+    const envelope = await createEnvelope({
+      userId: user.id,
+      teamId,
+      internalVersion: 2,
+      data: {
+        type,
+        title,
+        externalId,
+        visibility,
+        globalAccessAuth,
+        globalActionAuth,
+        recipients,
+        folderId,
+        envelopeItems: items,
+      },
+      meta,
+      normalizePdf: true,
+      requestMetadata: ctx.metadata,
+    });
+
+    return {
+      id: envelope.id,
+    };
+  });

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

@@ -0,0 +1,86 @@
+import { EnvelopeType } from '@prisma/client';
+import { z } from 'zod';
+
+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 {
+  ZFieldHeightSchema,
+  ZFieldPageNumberSchema,
+  ZFieldPageXSchema,
+  ZFieldPageYSchema,
+  ZFieldWidthSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+import {
+  ZDocumentExternalIdSchema,
+  ZDocumentTitleSchema,
+  ZDocumentVisibilitySchema,
+} from '../document-router/schema';
+import { ZCreateRecipientSchema } from '../recipient-router/schema';
+
+// 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 ZCreateEnvelopeRequestSchema = z.object({
+  title: ZDocumentTitleSchema,
+  type: z.nativeEnum(EnvelopeType),
+  externalId: ZDocumentExternalIdSchema.optional(),
+  visibility: ZDocumentVisibilitySchema.optional(),
+  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(
+      '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({
+            documentDataId: z
+              .string()
+              .describe(
+                'The ID of the document data to create the field on. If empty, the first document data will be used.',
+              ),
+            page: ZFieldPageNumberSchema,
+            positionX: ZFieldPageXSchema,
+            positionY: ZFieldPageYSchema,
+            width: ZFieldWidthSchema,
+            height: ZFieldHeightSchema,
+          }),
+        )
+          .array()
+          .optional(),
+      }),
+    )
+    .optional(),
+  meta: ZDocumentMetaCreateSchema.optional(),
+});
+
+export const ZCreateEnvelopeResponseSchema = z.object({
+  id: z.string(),
+});
+
+export type TCreateEnvelopeRequest = z.infer<typeof ZCreateEnvelopeRequestSchema>;
+export type TCreateEnvelopeResponse = z.infer<typeof ZCreateEnvelopeResponseSchema>;

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

@@ -0,0 +1,64 @@
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZDeleteEnvelopeItemRequestSchema,
+  ZDeleteEnvelopeItemResponseSchema,
+} from './delete-envelope-item.types';
+
+export const deleteEnvelopeItemRoute = authenticatedProcedure
+  .input(ZDeleteEnvelopeItemRequestSchema)
+  .output(ZDeleteEnvelopeItemResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, envelopeItemId } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+        envelopeItemId,
+      },
+    });
+
+    const { envelopeWhereInput } = await getEnvelopeWhereInput({
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+      userId: user.id,
+      teamId,
+    });
+
+    const envelope = await prisma.envelope.findUnique({
+      where: envelopeWhereInput,
+      include: {
+        recipients: true,
+      },
+    });
+
+    if (!envelope) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Envelope not found',
+      });
+    }
+
+    if (!canEnvelopeItemsBeModified(envelope, envelope.recipients)) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope item is not editable',
+      });
+    }
+
+    await prisma.envelopeItem.delete({
+      where: {
+        id: envelopeItemId,
+        envelopeId: envelope.id,
+      },
+    });
+
+    // Todo: Envelopes - Audit logs?
+    // Todo: Envelopes - Delete the document data as well?
+  });

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const ZDeleteEnvelopeItemRequestSchema = z.object({
+  envelopeId: z.string(),
+  envelopeItemId: z.string(),
+});
+
+export const ZDeleteEnvelopeItemResponseSchema = z.void();
+
+export type TDeleteEnvelopeItemRequest = z.infer<typeof ZDeleteEnvelopeItemRequestSchema>;
+export type TDeleteEnvelopeItemResponse = z.infer<typeof ZDeleteEnvelopeItemResponseSchema>;

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

@@ -0,0 +1,50 @@
+import { EnvelopeType } from '@prisma/client';
+import { match } from 'ts-pattern';
+
+import { deleteDocument } from '@documenso/lib/server-only/document/delete-document';
+import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZDeleteEnvelopeRequestSchema,
+  ZDeleteEnvelopeResponseSchema,
+} from './delete-envelope.types';
+
+export const deleteEnvelopeRoute = authenticatedProcedure
+  // .meta(deleteEnvelopeMeta)
+  .input(ZDeleteEnvelopeRequestSchema)
+  .output(ZDeleteEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId, envelopeType } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    await match(envelopeType)
+      .with(EnvelopeType.DOCUMENT, async () =>
+        deleteDocument({
+          userId: ctx.user.id,
+          teamId,
+          id: {
+            type: 'envelopeId',
+            id: envelopeId,
+          },
+          requestMetadata: ctx.metadata,
+        }),
+      )
+      .with(EnvelopeType.TEMPLATE, async () =>
+        deleteTemplate({
+          userId: ctx.user.id,
+          teamId,
+          id: {
+            type: 'envelopeId',
+            id: envelopeId,
+          },
+        }),
+      )
+      .exhaustive();
+  });

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

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

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

@@ -0,0 +1,55 @@
+import { updateDocumentMeta } from '@documenso/lib/server-only/document-meta/upsert-document-meta';
+import { sendDocument } from '@documenso/lib/server-only/document/send-document';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZDistributeEnvelopeRequestSchema,
+  ZDistributeEnvelopeResponseSchema,
+} from './distribute-envelope.types';
+
+export const distributeEnvelopeRoute = authenticatedProcedure
+  // .meta(distributeEnvelopeMeta)
+  .input(ZDistributeEnvelopeRequestSchema)
+  .output(ZDistributeEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId, meta = {} } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    if (Object.values(meta).length > 0) {
+      await updateDocumentMeta({
+        userId: ctx.user.id,
+        teamId,
+        id: {
+          type: 'envelopeId',
+          id: envelopeId,
+        },
+        subject: meta.subject,
+        message: meta.message,
+        dateFormat: meta.dateFormat,
+        timezone: meta.timezone,
+        redirectUrl: meta.redirectUrl,
+        distributionMethod: meta.distributionMethod,
+        emailSettings: meta.emailSettings,
+        language: meta.language,
+        emailId: meta.emailId,
+        emailReplyTo: meta.emailReplyTo,
+        requestMetadata: ctx.metadata,
+      });
+    }
+
+    await sendDocument({
+      userId: ctx.user.id,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      teamId,
+      requestMetadata: ctx.metadata,
+    });
+  });

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+
+import { ZDocumentMetaUpdateSchema } from '@documenso/lib/types/document-meta';
+
+// export const distributeEnvelopeMeta: TrpcRouteMeta = {
+//   openapi: {
+//     method: 'POST',
+//     path: '/envelope/distribute',
+//     summary: 'Distribute envelope',
+//     description: 'Send the document out to recipients based on your distribution method',
+//     tags: ['Envelope'],
+//   },
+// };
+
+export const ZDistributeEnvelopeRequestSchema = z.object({
+  envelopeId: z.string().describe('The ID of the envelope to send.'),
+  meta: ZDocumentMetaUpdateSchema.pick({
+    subject: true,
+    message: true,
+    timezone: true,
+    dateFormat: true,
+    distributionMethod: true,
+    redirectUrl: true,
+    language: true,
+    emailId: true,
+    emailReplyTo: true,
+    emailSettings: true,
+  }).optional(),
+});
+
+export const ZDistributeEnvelopeResponseSchema = z.void();
+
+export type TDistributeEnvelopeRequest = z.infer<typeof ZDistributeEnvelopeRequestSchema>;
+export type TDistributeEnvelopeResponse = z.infer<typeof ZDistributeEnvelopeResponseSchema>;

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

@@ -0,0 +1,34 @@
+import { duplicateEnvelope } from '@documenso/lib/server-only/envelope/duplicate-envelope';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZDuplicateEnvelopeRequestSchema,
+  ZDuplicateEnvelopeResponseSchema,
+} from './duplicate-envelope.types';
+
+export const duplicateEnvelopeRoute = authenticatedProcedure
+  .input(ZDuplicateEnvelopeRequestSchema)
+  .output(ZDuplicateEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const duplicatedEnvelope = await duplicateEnvelope({
+      userId: ctx.user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+    });
+
+    return {
+      duplicatedEnvelopeId: duplicatedEnvelope.id,
+    };
+  });

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const ZDuplicateEnvelopeRequestSchema = z.object({
+  envelopeId: z.string(),
+});
+
+export const ZDuplicateEnvelopeResponseSchema = z.object({
+  duplicatedEnvelopeId: z.string(),
+});
+
+export type TDuplicateEnvelopeRequest = z.infer<typeof ZDuplicateEnvelopeRequestSchema>;
+export type TDuplicateEnvelopeResponse = z.infer<typeof ZDuplicateEnvelopeResponseSchema>;

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

@@ -0,0 +1,29 @@
+import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+
+import { authenticatedProcedure } from '../trpc';
+import { ZGetEnvelopeRequestSchema, ZGetEnvelopeResponseSchema } from './get-envelope.types';
+
+export const getEnvelopeRoute = authenticatedProcedure
+  // .meta(getEnvelopeMeta)
+  .input(ZGetEnvelopeRequestSchema)
+  .output(ZGetEnvelopeResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { teamId, user } = ctx;
+    const { envelopeId } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await getEnvelopeById({
+      userId: user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+    });
+  });

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+import { ZEnvelopeSchema } from '@documenso/lib/types/envelope';
+
+// export const getEnvelopeMeta: TrpcRouteMeta = {
+//   openapi: {
+//     method: 'GET',
+//     path: '/envelope/{envelopeId}',
+//     summary: 'Get envelope',
+//     description: 'Returns a envelope given an ID',
+//     tags: ['Envelope'],
+//   },
+// };
+
+export const ZGetEnvelopeRequestSchema = z.object({
+  envelopeId: z.string(),
+});
+
+export const ZGetEnvelopeResponseSchema = ZEnvelopeSchema;
+
+export type TGetEnvelopeRequest = z.infer<typeof ZGetEnvelopeRequestSchema>;
+export type TGetEnvelopeResponse = z.infer<typeof ZGetEnvelopeResponseSchema>;

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

@@ -0,0 +1,34 @@
+import { resendDocument } from '@documenso/lib/server-only/document/resend-document';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZRedistributeEnvelopeRequestSchema,
+  ZRedistributeEnvelopeResponseSchema,
+} from './redistribute-envelope.types';
+
+export const redistributeEnvelopeRoute = authenticatedProcedure
+  // .meta(redistributeEnvelopeMeta)
+  .input(ZRedistributeEnvelopeRequestSchema)
+  .output(ZRedistributeEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId, recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+        recipients,
+      },
+    });
+
+    await resendDocument({
+      userId: ctx.user.id,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      recipients,
+      requestMetadata: ctx.metadata,
+    });
+  });

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

@@ -0,0 +1,25 @@
+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'],
+//   },
+// };
+
+export const ZRedistributeEnvelopeRequestSchema = z.object({
+  envelopeId: z.string(),
+  recipients: z
+    .array(z.number())
+    .min(1)
+    .describe('The IDs of the recipients to redistribute the envelope to.'),
+});
+
+export const ZRedistributeEnvelopeResponseSchema = z.void();
+
+export type TRedistributeEnvelopeRequest = z.infer<typeof ZRedistributeEnvelopeRequestSchema>;
+export type TRedistributeEnvelopeResponse = z.infer<typeof ZRedistributeEnvelopeResponseSchema>;

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

@@ -0,0 +1,38 @@
+import { router } from '../trpc';
+import { createEnvelopeRoute } from './create-envelope';
+import { createEnvelopeItemsRoute } from './create-envelope-items';
+import { deleteEnvelopeRoute } from './delete-envelope';
+import { deleteEnvelopeItemRoute } from './delete-envelope-item';
+import { distributeEnvelopeRoute } from './distribute-envelope';
+import { duplicateEnvelopeRoute } from './duplicate-envelope';
+import { getEnvelopeRoute } from './get-envelope';
+import { redistributeEnvelopeRoute } from './redistribute-envelope';
+import { setEnvelopeFieldsRoute } from './set-envelope-fields';
+import { setEnvelopeRecipientsRoute } from './set-envelope-recipients';
+import { signEnvelopeFieldRoute } from './sign-envelope-field';
+import { updateEnvelopeRoute } from './update-envelope';
+import { updateEnvelopeItemsRoute } from './update-envelope-items';
+
+export const envelopeRouter = router({
+  get: getEnvelopeRoute,
+  create: createEnvelopeRoute,
+  update: updateEnvelopeRoute,
+  delete: deleteEnvelopeRoute,
+  duplicate: duplicateEnvelopeRoute,
+  distribute: distributeEnvelopeRoute,
+  redistribute: redistributeEnvelopeRoute,
+  // share: shareEnvelopeRoute,
+
+  item: {
+    createMany: createEnvelopeItemsRoute,
+    updateMany: updateEnvelopeItemsRoute,
+    delete: deleteEnvelopeItemRoute,
+  },
+  recipient: {
+    set: setEnvelopeRecipientsRoute,
+  },
+  field: {
+    set: setEnvelopeFieldsRoute,
+    sign: signEnvelopeFieldRoute,
+  },
+});

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

@@ -0,0 +1,66 @@
+import { EnvelopeType } from '@prisma/client';
+import { match } from 'ts-pattern';
+
+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 { authenticatedProcedure } from '../trpc';
+import {
+  ZSetEnvelopeFieldsRequestSchema,
+  ZSetEnvelopeFieldsResponseSchema,
+} from './set-envelope-fields.types';
+
+// Note: This is intended to always be an internal route.
+export const setEnvelopeFieldsRoute = authenticatedProcedure
+  .input(ZSetEnvelopeFieldsRequestSchema)
+  .output(ZSetEnvelopeFieldsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId, envelopeType, fields } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    await match(envelopeType)
+      .with(EnvelopeType.DOCUMENT, async () =>
+        setFieldsForDocument({
+          userId: ctx.user.id,
+          teamId,
+          id: {
+            type: 'envelopeId',
+            id: envelopeId,
+          },
+          fields: fields.map((field) => ({
+            ...field,
+            pageNumber: field.page,
+            pageX: field.positionX,
+            pageY: field.positionY,
+            pageWidth: field.width,
+            pageHeight: field.height,
+          })),
+          requestMetadata: ctx.metadata,
+        }),
+      )
+      .with(EnvelopeType.TEMPLATE, async () =>
+        setFieldsForTemplate({
+          userId: ctx.user.id,
+          teamId,
+          id: {
+            type: 'envelopeId',
+            id: envelopeId,
+          },
+          fields: fields.map((field) => ({
+            ...field,
+            pageNumber: field.page,
+            pageX: field.positionX,
+            pageY: field.positionY,
+            pageWidth: field.width,
+            pageHeight: field.height,
+          })),
+        }),
+      )
+      .exhaustive();
+  });

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

@@ -0,0 +1,51 @@
+import { EnvelopeType, FieldType } from '@prisma/client';
+import { z } from 'zod';
+
+import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
+
+export const ZSetEnvelopeFieldsRequestSchema = z.object({
+  envelopeId: z.string(),
+  envelopeType: z.nativeEnum(EnvelopeType),
+  fields: z.array(
+    z.object({
+      id: z
+        .number()
+        .optional()
+        .describe('The id of the field. If not provided, a new field will be created.'),
+      envelopeItemId: z.string().describe('The id of the envelope item to put the field on'),
+      recipientId: z.number(),
+      type: z.nativeEnum(FieldType),
+      page: z
+        .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?
+    }),
+  ),
+});
+
+export const ZSetEnvelopeFieldsResponseSchema = z.void();
+
+export type TSetEnvelopeFieldsRequest = z.infer<typeof ZSetEnvelopeFieldsRequestSchema>;
+export type TSetEnvelopeFieldsResponse = z.infer<typeof ZSetEnvelopeFieldsResponseSchema>;

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

@@ -0,0 +1,51 @@
+import { EnvelopeType } from '@prisma/client';
+import { match } from 'ts-pattern';
+
+import { setDocumentRecipients } from '@documenso/lib/server-only/recipient/set-document-recipients';
+import { setTemplateRecipients } from '@documenso/lib/server-only/recipient/set-template-recipients';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZSetEnvelopeRecipientsRequestSchema,
+  ZSetEnvelopeRecipientsResponseSchema,
+} from './set-envelope-recipients.types';
+
+export const setEnvelopeRecipientsRoute = authenticatedProcedure
+  .input(ZSetEnvelopeRecipientsRequestSchema)
+  .output(ZSetEnvelopeRecipientsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId, envelopeType, recipients } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    return await match(envelopeType)
+      .with(EnvelopeType.DOCUMENT, async () =>
+        setDocumentRecipients({
+          userId: ctx.user.id,
+          teamId,
+          id: {
+            type: 'envelopeId',
+            id: envelopeId,
+          },
+          recipients,
+          requestMetadata: ctx.metadata,
+        }),
+      )
+      .with(EnvelopeType.TEMPLATE, async () =>
+        setTemplateRecipients({
+          userId: ctx.user.id,
+          teamId,
+          id: {
+            type: 'envelopeId',
+            id: envelopeId,
+          },
+          recipients,
+        }),
+      )
+      .exhaustive();
+  });

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

@@ -0,0 +1,30 @@
+import { EnvelopeType, RecipientRole } from '@prisma/client';
+import { z } from 'zod';
+
+import { ZRecipientActionAuthTypesSchema } from '@documenso/lib/types/document-auth';
+import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
+
+export const ZSetEnvelopeRecipientsRequestSchema = z.object({
+  envelopeId: z.string(),
+  envelopeType: z.nativeEnum(EnvelopeType),
+  recipients: z.array(
+    z.object({
+      id: z.number().optional(),
+      email: z.string().toLowerCase().email().min(1).max(254),
+      name: z.string().max(255),
+      role: z.nativeEnum(RecipientRole),
+      signingOrder: z.number().optional(),
+      actionAuth: z.array(ZRecipientActionAuthTypesSchema).optional().default([]),
+    }),
+  ),
+});
+
+export const ZSetEnvelopeRecipientsResponseSchema = z.object({
+  recipients: ZRecipientLiteSchema.omit({
+    documentId: true,
+    templateId: true,
+  }).array(),
+});
+
+export type TSetEnvelopeRecipientsRequest = z.infer<typeof ZSetEnvelopeRecipientsRequestSchema>;
+export type TSetEnvelopeRecipientsResponse = z.infer<typeof ZSetEnvelopeRecipientsResponseSchema>;

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

@@ -0,0 +1,472 @@
+import { DocumentStatus, FieldType, RecipientRole, SigningStatus } from '@prisma/client';
+import { DateTime } from 'luxon';
+import { P, match } from 'ts-pattern';
+import { z } from 'zod';
+
+import { validateCheckboxField } from '@documenso/lib/advanced-fields-validation/validate-checkbox';
+import { validateDropdownField } from '@documenso/lib/advanced-fields-validation/validate-dropdown';
+import { validateNumberField } from '@documenso/lib/advanced-fields-validation/validate-number';
+import { validateRadioField } from '@documenso/lib/advanced-fields-validation/validate-radio';
+import { validateTextField } from '@documenso/lib/advanced-fields-validation/validate-text';
+import { DEFAULT_DOCUMENT_DATE_FORMAT } from '@documenso/lib/constants/date-formats';
+import { DEFAULT_DOCUMENT_TIME_ZONE } from '@documenso/lib/constants/time-zones';
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { validateFieldAuth } from '@documenso/lib/server-only/document/validate-field-auth';
+import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
+import {
+  ZCheckboxFieldMeta,
+  ZDropdownFieldMeta,
+  ZNumberFieldMeta,
+  ZRadioFieldMeta,
+  ZTextFieldMeta,
+} from '@documenso/lib/types/field-meta';
+import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
+import { prisma } from '@documenso/prisma';
+
+import { procedure } from '../trpc';
+import {
+  ZSignEnvelopeFieldRequestSchema,
+  ZSignEnvelopeFieldResponseSchema,
+} from './sign-envelope-field.types';
+
+// Note that this is an unauthenticated public procedure route.
+export const signEnvelopeFieldRoute = procedure
+  .input(ZSignEnvelopeFieldRequestSchema)
+  .output(ZSignEnvelopeFieldResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, metadata } = ctx;
+    const { token, fieldId, fieldValue, authOptions } = input;
+
+    ctx.logger.info({
+      input: {
+        fieldId,
+      },
+    });
+
+    const recipient = await prisma.recipient.findFirst({
+      where: {
+        token,
+      },
+    });
+
+    if (!recipient) {
+      throw new AppError(AppErrorCode.NOT_FOUND);
+    }
+
+    const field = await prisma.field.findFirstOrThrow({
+      where: {
+        id: fieldId,
+        recipient: {
+          ...(recipient.role !== RecipientRole.ASSISTANT
+            ? {
+                id: recipient.id,
+              }
+            : {
+                signingStatus: {
+                  not: SigningStatus.SIGNED,
+                },
+                signingOrder: {
+                  gte: recipient.signingOrder ?? 0,
+                },
+              }),
+        },
+      },
+      include: {
+        envelope: {
+          include: {
+            recipients: true,
+            documentMeta: true,
+          },
+        },
+        recipient: true,
+      },
+    });
+
+    const { envelope } = field;
+    const { documentMeta } = envelope;
+
+    if (!envelope || !recipient) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: `Document not found for field ${field.id}`,
+      });
+    }
+
+    if (envelope.internalVersion !== 2) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: `Envelope ${envelope.id} is not a version 2 envelope`,
+      });
+    }
+
+    if (fieldValue.type !== field.type) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Selected values do not match the field values',
+      });
+    }
+
+    if (envelope.deletedAt) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: `Document ${envelope.id} has been deleted`,
+      });
+    }
+
+    if (envelope.status !== DocumentStatus.PENDING) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: `Document ${envelope.id} must be pending for signing`,
+      });
+    }
+
+    if (
+      recipient.signingStatus === SigningStatus.SIGNED ||
+      field.recipient.signingStatus === SigningStatus.SIGNED
+    ) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: `Recipient ${recipient.id} has already signed`,
+      });
+    }
+
+    // Todo: Envelopes - Need to auto insert read only fields during sealing.
+    if (field.fieldMeta?.readOnly) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: `Field ${fieldId} is read only`,
+      });
+    }
+
+    // Unreachable code based on the above query but we need to satisfy TypeScript
+    if (field.recipientId === null) {
+      throw new Error(`Field ${fieldId} has no recipientId`);
+    }
+
+    let signatureImageAsBase64: string | null = null;
+    let typedSignature: string | null = null;
+
+    const insertionValues: { customText: string; inserted: boolean } = match(fieldValue)
+      .with({ type: FieldType.EMAIL }, (fieldValue) => {
+        const parsedEmailValue = z.string().email().nullable().safeParse(fieldValue.value);
+
+        if (!parsedEmailValue.success) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Invalid email',
+          });
+        }
+
+        if (parsedEmailValue.data === null) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        return {
+          customText: parsedEmailValue.data,
+          inserted: true,
+        };
+      })
+      .with({ type: P.union(FieldType.NAME, FieldType.INITIALS) }, (fieldValue) => {
+        const parsedGenericStringValue = z.string().min(1).nullable().safeParse(fieldValue.value);
+
+        if (!parsedGenericStringValue.success) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Value is required',
+          });
+        }
+
+        if (parsedGenericStringValue.data === null) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        return {
+          customText: parsedGenericStringValue.data,
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.DATE }, (fieldValue) => {
+        if (!fieldValue.value) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        return {
+          customText: DateTime.now()
+            .setZone(documentMeta.timezone ?? DEFAULT_DOCUMENT_TIME_ZONE)
+            .toFormat(documentMeta.dateFormat ?? DEFAULT_DOCUMENT_DATE_FORMAT),
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.NUMBER }, (fieldValue) => {
+        if (!fieldValue.value) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        const numberFieldParsedMeta = ZNumberFieldMeta.parse(field.fieldMeta);
+        const errors = validateNumberField(
+          fieldValue.value.toString(),
+          numberFieldParsedMeta,
+          true,
+        );
+
+        // Todo
+        if (errors.length > 0) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Invalid number',
+          });
+        }
+
+        return {
+          customText: fieldValue.value.toString(),
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.TEXT }, (fieldValue) => {
+        if (fieldValue.value === null) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        const parsedTextFieldMeta = ZTextFieldMeta.parse(field.fieldMeta);
+        const errors = validateTextField(fieldValue.value, parsedTextFieldMeta, true);
+
+        // Todo
+        if (errors.length > 0) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Invalid email',
+          });
+        }
+
+        return {
+          customText: fieldValue.value,
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.RADIO }, (fieldValue) => {
+        if (fieldValue.value === null) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        const parsedRadioFieldParsedMeta = ZRadioFieldMeta.parse(field.fieldMeta);
+        const errors = validateRadioField(fieldValue.value, parsedRadioFieldParsedMeta, true);
+
+        if (errors.length > 0) {
+          throw new Error(errors.join(', '));
+        }
+
+        // Todo
+        if (errors.length > 0) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Invalid radio value',
+          });
+        }
+
+        return {
+          customText: fieldValue.value,
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.CHECKBOX }, (fieldValue) => {
+        if (fieldValue.value === null) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        // Todo: Envelopes - This won't work.
+
+        const parsedCheckboxFieldParsedMeta = ZCheckboxFieldMeta.parse(field.fieldMeta);
+
+        const checkboxFieldValues = parsedCheckboxFieldParsedMeta.values || [];
+
+        const { value } = fieldValue;
+
+        const selectedValues = checkboxFieldValues.filter(({ id }) => value.some((v) => v === id));
+
+        if (selectedValues.length !== value.length) {
+          throw new AppError(AppErrorCode.NOT_FOUND, {
+            message: 'Selected values do not match the checkbox field values',
+          });
+        }
+
+        const errors = validateCheckboxField(
+          selectedValues.map(({ value }) => value),
+          parsedCheckboxFieldParsedMeta,
+          true,
+        );
+
+        if (errors.length > 0) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Invalid checkbox value:' + errors.join(', '),
+          });
+        }
+
+        return {
+          customText: JSON.stringify(fieldValue.value),
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.DROPDOWN }, (fieldValue) => {
+        if (fieldValue.value === null) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        const parsedDropdownFieldMeta = ZDropdownFieldMeta.parse(field.fieldMeta);
+        const errors = validateDropdownField(fieldValue.value, parsedDropdownFieldMeta, true);
+
+        // Todo
+        if (errors.length > 0) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Invalid dropdown value',
+          });
+        }
+
+        return {
+          customText: fieldValue.value,
+          inserted: true,
+        };
+      })
+      .with({ type: FieldType.SIGNATURE }, (fieldValue) => {
+        const { value, isBase64 } = fieldValue;
+
+        if (!value) {
+          return {
+            customText: '',
+            inserted: false,
+          };
+        }
+
+        signatureImageAsBase64 = isBase64 ? value : null;
+        typedSignature = !isBase64 ? value : null;
+
+        if (documentMeta.typedSignatureEnabled === false && typedSignature) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: 'Typed signatures are not allowed. Please draw your signature',
+          });
+        }
+
+        return {
+          customText: '',
+          inserted: true,
+        };
+      })
+      .exhaustive();
+
+    const derivedRecipientActionAuth = await validateFieldAuth({
+      documentAuthOptions: envelope.authOptions,
+      recipient,
+      field,
+      userId: user?.id,
+      authOptions,
+    });
+
+    const assistant = recipient.role === RecipientRole.ASSISTANT ? recipient : undefined;
+
+    return await prisma.$transaction(async (tx) => {
+      const updatedField = await tx.field.update({
+        where: {
+          id: field.id,
+        },
+        data: {
+          customText: insertionValues.customText,
+          inserted: insertionValues.inserted,
+        },
+        include: {
+          signature: true,
+        },
+      });
+
+      if (field.type === FieldType.SIGNATURE) {
+        const signature = await tx.signature.upsert({
+          where: {
+            fieldId: field.id,
+          },
+          create: {
+            fieldId: field.id,
+            recipientId: field.recipientId,
+            signatureImageAsBase64: signatureImageAsBase64,
+            typedSignature: typedSignature,
+          },
+          update: {
+            signatureImageAsBase64: signatureImageAsBase64,
+            typedSignature: typedSignature,
+          },
+        });
+
+        // Dirty but I don't want to deal with type information
+        Object.assign(updatedField, {
+          signature,
+        });
+      }
+
+      await tx.documentAuditLog.create({
+        data: createDocumentAuditLogData({
+          type:
+            assistant && field.recipientId !== assistant.id
+              ? DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_FIELD_PREFILLED
+              : DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_FIELD_INSERTED,
+          envelopeId: envelope.id,
+          user: {
+            email: assistant?.email ?? recipient.email,
+            name: assistant?.name ?? recipient.name,
+          },
+          requestMetadata: metadata.requestMetadata,
+          data: {
+            recipientEmail: recipient.email,
+            recipientId: recipient.id,
+            recipientName: recipient.name,
+            recipientRole: recipient.role,
+            fieldId: updatedField.secondaryId,
+            field: match(updatedField.type)
+              .with(FieldType.SIGNATURE, FieldType.FREE_SIGNATURE, (type) => ({
+                type,
+                data: signatureImageAsBase64 || typedSignature || '',
+              }))
+              .with(
+                FieldType.DATE,
+                FieldType.EMAIL,
+                FieldType.NAME,
+                FieldType.TEXT,
+                FieldType.INITIALS,
+                (type) => ({
+                  type,
+                  data: updatedField.customText,
+                }),
+              )
+              .with(
+                FieldType.NUMBER,
+                FieldType.RADIO,
+                FieldType.CHECKBOX,
+                FieldType.DROPDOWN,
+                (type) => ({
+                  type,
+                  data: updatedField.customText,
+                }),
+              )
+              .exhaustive(),
+            fieldSecurity: derivedRecipientActionAuth
+              ? {
+                  type: derivedRecipientActionAuth,
+                }
+              : undefined,
+          },
+        }),
+      });
+
+      return {
+        signedField: updatedField,
+      };
+    });
+  });

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

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+import { ZRecipientActionAuthSchema } from '@documenso/lib/types/document-auth';
+import { ZFieldSchema } from '@documenso/lib/types/field';
+import { FieldType } from '@documenso/prisma/client';
+import SignatureSchema from '@documenso/prisma/generated/zod/modelSchema/SignatureSchema';
+
+export const ZSignEnvelopeFieldValue = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(FieldType.CHECKBOX),
+    value: z.array(z.number()),
+  }),
+  z.object({
+    type: z.literal(FieldType.RADIO),
+    value: z.string().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.NUMBER),
+    value: z.number().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.EMAIL),
+    value: z.string().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.NAME),
+    value: z.string().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.INITIALS),
+    value: z.string().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.TEXT),
+    value: z.string().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.DROPDOWN),
+    value: z.string().nullable(),
+  }),
+  z.object({
+    type: z.literal(FieldType.DATE),
+    value: z.boolean(),
+  }),
+  z.object({
+    type: z.literal(FieldType.SIGNATURE),
+    value: z.string().nullable(),
+    isBase64: z.boolean(),
+  }),
+]);
+
+export const ZSignEnvelopeFieldRequestSchema = z.object({
+  token: z.string(),
+  fieldId: z.number(),
+  fieldValue: ZSignEnvelopeFieldValue,
+  authOptions: ZRecipientActionAuthSchema.optional(),
+});
+
+export const ZSignEnvelopeFieldResponseSchema = z.object({
+  signedField: ZFieldSchema.omit({
+    templateId: true,
+    documentId: true,
+  }).extend({
+    signature: SignatureSchema.nullish(),
+  }),
+});
+
+export type TSignEnvelopeFieldValue = z.infer<typeof ZSignEnvelopeFieldValue>;
+export type TSignEnvelopeFieldRequest = z.infer<typeof ZSignEnvelopeFieldRequestSchema>;
+export type TSignEnvelopeFieldResponse = z.infer<typeof ZSignEnvelopeFieldResponseSchema>;

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

@@ -0,0 +1,99 @@
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZUpdateEnvelopeItemsRequestSchema,
+  ZUpdateEnvelopeItemsResponseSchema,
+} from './update-envelope-items.types';
+
+export const updateEnvelopeItemsRoute = authenticatedProcedure
+  .input(ZUpdateEnvelopeItemsRequestSchema)
+  .output(ZUpdateEnvelopeItemsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { user, teamId } = ctx;
+    const { envelopeId, data } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const { envelopeWhereInput } = await getEnvelopeWhereInput({
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      type: null,
+      userId: user.id,
+      teamId,
+    });
+
+    const envelope = await prisma.envelope.findUnique({
+      where: envelopeWhereInput,
+      include: {
+        recipients: true,
+        envelopeItems: true,
+      },
+    });
+
+    if (!envelope) {
+      throw new AppError(AppErrorCode.NOT_FOUND, {
+        message: 'Envelope not found',
+      });
+    }
+
+    if (data.length === 0) {
+      throw new AppError(AppErrorCode.INVALID_BODY, {
+        message: 'Envelope items are required',
+      });
+    }
+
+    if (!canEnvelopeItemsBeModified(envelope, envelope.recipients)) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'Envelope item is not editable',
+      });
+    }
+
+    // Check that the items belong to the envelope.
+    const itemsBelongToEnvelope = data.every((item) =>
+      envelope.envelopeItems.some(({ id }) => item.envelopeItemId === id),
+    );
+
+    if (!itemsBelongToEnvelope) {
+      throw new AppError(AppErrorCode.INVALID_REQUEST, {
+        message: 'One or more envelope items to update do not exist',
+      });
+    }
+
+    const updatedEnvelopeItems = await Promise.all(
+      data.map(async ({ envelopeItemId, order, title }) =>
+        prisma.envelopeItem.update({
+          where: {
+            envelopeId: envelope.id,
+            id: envelopeItemId,
+          },
+          data: {
+            order,
+            title,
+          },
+          select: {
+            id: true,
+            order: true,
+            title: true,
+            envelopeId: true,
+          },
+        }),
+      ),
+    );
+
+    // Todo: Envelope - Audit logs?
+    // Todo: Envelopes - Delete the document data as well?
+
+    return {
+      updatedEnvelopeItems,
+    };
+  });

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+
+import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
+
+import { ZDocumentTitleSchema } from '../document-router/schema';
+
+export const ZUpdateEnvelopeItemsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: z
+    .object({
+      envelopeItemId: z.string(),
+      order: z.number().int().min(1).optional(),
+      title: ZDocumentTitleSchema.optional(),
+    })
+    .array()
+    .min(1),
+});
+
+export const ZUpdateEnvelopeItemsResponseSchema = z.object({
+  updatedEnvelopeItems: EnvelopeItemSchema.pick({
+    id: true,
+    order: true,
+    title: true,
+    envelopeId: true,
+  }).array(),
+});
+
+export type TUpdateEnvelopeItemsRequest = z.infer<typeof ZUpdateEnvelopeItemsRequestSchema>;
+export type TUpdateEnvelopeItemsResponse = z.infer<typeof ZUpdateEnvelopeItemsResponseSchema>;

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

@@ -0,0 +1,36 @@
+import { updateEnvelope } from '@documenso/lib/server-only/envelope/update-envelope';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZUpdateEnvelopeRequestSchema,
+  ZUpdateEnvelopeResponseSchema,
+} from './update-envelope.types';
+
+export const updateEnvelopeRoute = authenticatedProcedure
+  // .meta(updateEnvelopeTrpcMeta)
+  .input(ZUpdateEnvelopeRequestSchema)
+  .output(ZUpdateEnvelopeResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { teamId } = ctx;
+    const { envelopeId, data, meta = {} } = input;
+
+    ctx.logger.info({
+      input: {
+        envelopeId,
+      },
+    });
+
+    const userId = ctx.user.id;
+
+    return await updateEnvelope({
+      userId,
+      teamId,
+      id: {
+        type: 'envelopeId',
+        id: envelopeId,
+      },
+      data,
+      meta,
+      requestMetadata: ctx.metadata,
+    });
+  });

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

@@ -0,0 +1,46 @@
+import { EnvelopeType } from '@prisma/client';
+// import type { OpenApiMeta } from 'trpc-to-openapi';
+import { z } from 'zod';
+
+import {
+  ZDocumentAccessAuthTypesSchema,
+  ZDocumentActionAuthTypesSchema,
+} from '@documenso/lib/types/document-auth';
+import { ZDocumentMetaUpdateSchema } from '@documenso/lib/types/document-meta';
+import { ZEnvelopeLiteSchema } from '@documenso/lib/types/envelope';
+
+import {
+  ZDocumentExternalIdSchema,
+  ZDocumentTitleSchema,
+  ZDocumentVisibilitySchema,
+} from '../document-router/schema';
+
+// 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(),
+      externalId: ZDocumentExternalIdSchema.nullish(),
+      visibility: ZDocumentVisibilitySchema.optional(),
+      globalAccessAuth: z.array(ZDocumentAccessAuthTypesSchema).optional(),
+      globalActionAuth: z.array(ZDocumentActionAuthTypesSchema).optional(),
+      folderId: z.string().nullish(),
+    })
+    .optional(),
+  meta: ZDocumentMetaUpdateSchema.optional(),
+});
+
+export const ZUpdateEnvelopeResponseSchema = ZEnvelopeLiteSchema;
+
+export type TUpdateEnvelopeRequest = z.infer<typeof ZUpdateEnvelopeRequestSchema>;
+export type TUpdateEnvelopeResponse = z.infer<typeof ZUpdateEnvelopeResponseSchema>;