feat: add envelopes api (#2105)

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,53 @@
+import { z } from 'zod';
+
+import {
+  ZClampedFieldHeightSchema,
+  ZClampedFieldPositionXSchema,
+  ZClampedFieldPositionYSchema,
+  ZClampedFieldWidthSchema,
+  ZFieldPageNumberSchema,
+  ZFieldSchema,
+} from '@documenso/lib/types/field';
+import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
+
+import type { TrpcRouteMeta } from '../../trpc';
+
+export const createEnvelopeFieldsMeta: TrpcRouteMeta = {
+  openapi: {
+    method: 'POST',
+    path: '/envelope/field/create-many',
+    contentTypes: ['multipart/form-data'],
+    summary: 'Create envelope fields',
+    description: 'Create multiple fields for an envelope',
+    tags: ['Envelope Fields'],
+  },
+};
+
+const ZCreateFieldSchema = ZFieldAndMetaSchema.and(
+  z.object({
+    recipientId: z.number().describe('The ID of the recipient to create the field for'),
+    envelopeItemId: z
+      .string()
+      .optional()
+      .describe(
+        'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
+      ),
+    page: ZFieldPageNumberSchema,
+    positionX: ZClampedFieldPositionXSchema,
+    positionY: ZClampedFieldPositionYSchema,
+    width: ZClampedFieldWidthSchema,
+    height: ZClampedFieldHeightSchema,
+  }),
+);
+
+export const ZCreateEnvelopeFieldsRequestSchema = z.object({
+  envelopeId: z.string(),
+  data: ZCreateFieldSchema.array(),
+});
+
+export const ZCreateEnvelopeFieldsResponseSchema = z.object({
+  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,118 @@
+import { EnvelopeType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
+import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
+import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
+import { canRecipientFieldsBeModified } from '@documenso/lib/utils/recipients';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../../trpc';
+import {
+  ZDeleteEnvelopeFieldRequestSchema,
+  ZDeleteEnvelopeFieldResponseSchema,
+  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;
+    });
+  });

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+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 = z.void();
+
+export type TDeleteEnvelopeFieldRequest = z.infer<typeof ZDeleteEnvelopeFieldRequestSchema>;
+export type TDeleteEnvelopeFieldResponse = z.infer<typeof ZDeleteEnvelopeFieldResponseSchema>;

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

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