feat: attachments

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

@@ -0,0 +1,47 @@
+import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZGetDocumentAttachmentsResponseSchema,
+  ZGetDocumentAttachmentsSchema,
+} from './find-document-attachments.types';
+
+export const findDocumentAttachmentsRoute = authenticatedProcedure
+  .input(ZGetDocumentAttachmentsSchema)
+  .output(ZGetDocumentAttachmentsResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { documentId } = input;
+    const { user } = ctx;
+
+    const attachments = await findDocumentAttachments({
+      documentId,
+      userId: user.id,
+      teamId: ctx.teamId,
+    });
+
+    return attachments;
+  });
+
+export type FindDocumentAttachmentsOptions = {
+  documentId?: number;
+  userId: number;
+  teamId: number;
+};
+
+export const findDocumentAttachments = async ({
+  documentId,
+  userId,
+  teamId,
+}: FindDocumentAttachmentsOptions) => {
+  const attachments = await prisma.attachment.findMany({
+    where: {
+      document: {
+        id: documentId,
+        team: buildTeamWhereQuery({ teamId, userId }),
+      },
+    },
+  });
+
+  return attachments;
+};

packages/trpc/server/document-router/find-document-attachments.types.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+import { AttachmentType } from '@documenso/prisma/generated/types';
+
+export const ZGetDocumentAttachmentsSchema = z.object({
+  documentId: z.number(),
+});
+
+export const ZGetDocumentAttachmentsResponseSchema = z.array(
+  z.object({
+    id: z.string(),
+    label: z.string(),
+    url: z.string(),
+    type: z.nativeEnum(AttachmentType),
+  }),
+);

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

@@ -27,6 +27,7 @@ import { getPresignPostUrl } from '@documenso/lib/universal/upload/server-action
 import { isDocumentCompleted } from '@documenso/lib/utils/document';
 
 import { authenticatedProcedure, procedure, router } from '../trpc';
+import { findDocumentAttachmentsRoute } from './find-document-attachments';
 import { findInboxRoute } from './find-inbox';
 import { getInboxCountRoute } from './get-inbox-count';
 import {
@@ -55,6 +56,7 @@ import {
   ZSetSigningOrderForDocumentMutationSchema,
   ZSuccessResponseSchema,
 } from './schema';
+import { setDocumentAttachmentsRoute } from './set-document-attachments';
 import { updateDocumentRoute } from './update-document';
 
 export const documentRouter = router({
@@ -63,6 +65,10 @@ export const documentRouter = router({
     getCount: getInboxCountRoute,
   },
   updateDocument: updateDocumentRoute,
+  attachments: {
+    find: findDocumentAttachmentsRoute,
+    set: setDocumentAttachmentsRoute,
+  },
 
   /**
    * @private

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

@@ -0,0 +1,124 @@
+import type { Attachment, User } from '@prisma/client';
+
+import { AppError } from '@documenso/lib/errors/app-error';
+import { AppErrorCode } from '@documenso/lib/errors/app-error';
+import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
+import type { RequestMetadata } from '@documenso/lib/universal/extract-request-metadata';
+import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
+import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZSetDocumentAttachmentsResponseSchema,
+  ZSetDocumentAttachmentsSchema,
+} from './set-document-attachments.types';
+
+export const setDocumentAttachmentsRoute = authenticatedProcedure
+  .input(ZSetDocumentAttachmentsSchema)
+  .output(ZSetDocumentAttachmentsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { documentId, attachments } = input;
+
+    const updatedAttachments = await setDocumentAttachments({
+      documentId,
+      attachments,
+      user: ctx.user,
+      teamId: ctx.teamId,
+      requestMetadata: ctx.metadata.requestMetadata,
+    });
+
+    return updatedAttachments;
+  });
+
+export type CreateAttachmentsOptions = {
+  documentId: number;
+  attachments: Pick<Attachment, 'id' | 'label' | 'url' | 'type'>[];
+  user: Pick<User, 'id' | 'email' | 'name'>;
+  teamId: number;
+  requestMetadata: RequestMetadata;
+};
+
+export const setDocumentAttachments = async ({
+  documentId,
+  attachments,
+  user,
+  teamId,
+  requestMetadata,
+}: CreateAttachmentsOptions) => {
+  const document = await prisma.document.findUnique({
+    where: {
+      id: documentId,
+      team: buildTeamWhereQuery({ teamId, userId: user.id }),
+    },
+  });
+
+  if (!document) {
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: 'Document not found',
+    });
+  }
+
+  const existingAttachments = await prisma.attachment.findMany({
+    where: {
+      documentId,
+    },
+  });
+
+  const newIds = attachments.map((a) => a.id).filter(Boolean);
+  const toDelete = existingAttachments.filter((existing) => !newIds.includes(existing.id));
+
+  if (toDelete.length > 0) {
+    await prisma.attachment.deleteMany({
+      where: {
+        id: { in: toDelete.map((a) => a.id) },
+      },
+    });
+  }
+
+  const upsertedAttachments: Attachment[] = [];
+
+  for (const attachment of attachments) {
+    const updated = await prisma.attachment.upsert({
+      where: { id: attachment.id, documentId: document.id },
+      update: {
+        label: attachment.label,
+        url: attachment.url,
+        type: attachment.type,
+      },
+      create: {
+        label: attachment.label,
+        url: attachment.url,
+        type: attachment.type,
+        documentId,
+      },
+    });
+    upsertedAttachments.push(updated);
+  }
+
+  const isAttachmentsSame = upsertedAttachments.every((attachment) => {
+    const existingAttachment = existingAttachments.find((a) => a.id === attachment.id);
+    return (
+      existingAttachment?.label === attachment.label &&
+      existingAttachment?.url === attachment.url &&
+      existingAttachment?.type === attachment.type
+    );
+  });
+
+  if (!isAttachmentsSame) {
+    await prisma.documentAuditLog.create({
+      data: createDocumentAuditLogData({
+        type: DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_ATTACHMENTS_UPDATED,
+        documentId: document.id,
+        user,
+        data: {
+          from: existingAttachments,
+          to: upsertedAttachments,
+        },
+        requestMetadata,
+      }),
+    });
+  }
+
+  return upsertedAttachments;
+};

packages/trpc/server/document-router/set-document-attachments.types.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+import { AttachmentType } from '@documenso/prisma/generated/types';
+
+export const ZSetDocumentAttachmentsSchema = z.object({
+  documentId: z.number(),
+  attachments: z.array(
+    z.object({
+      id: z.string(),
+      label: z.string().min(1, 'Label is required'),
+      url: z.string().url('Invalid URL'),
+      type: z.nativeEnum(AttachmentType),
+    }),
+  ),
+});
+
+export type TSetDocumentAttachmentsSchema = z.infer<typeof ZSetDocumentAttachmentsSchema>;
+
+export const ZSetDocumentAttachmentsResponseSchema = z.array(
+  z.object({
+    id: z.string(),
+    label: z.string(),
+    url: z.string(),
+    type: z.nativeEnum(AttachmentType),
+  }),
+);

packages/trpc/server/template-router/find-template-attachments.ts

@@ -0,0 +1,46 @@
+import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZGetTemplateAttachmentsResponseSchema,
+  ZGetTemplateAttachmentsSchema,
+} from './find-template-attachments.types';
+
+export const findTemplateAttachmentsRoute = authenticatedProcedure
+  .input(ZGetTemplateAttachmentsSchema)
+  .output(ZGetTemplateAttachmentsResponseSchema)
+  .query(async ({ input, ctx }) => {
+    const { templateId } = input;
+
+    const attachments = await findTemplateAttachments({
+      templateId,
+      userId: ctx.user.id,
+      teamId: ctx.teamId,
+    });
+
+    return attachments;
+  });
+
+export type FindTemplateAttachmentsOptions = {
+  templateId: number;
+  userId: number;
+  teamId: number;
+};
+
+export const findTemplateAttachments = async ({
+  templateId,
+  userId,
+  teamId,
+}: FindTemplateAttachmentsOptions) => {
+  const attachments = await prisma.attachment.findMany({
+    where: {
+      template: {
+        id: templateId,
+        team: buildTeamWhereQuery({ teamId, userId }),
+      },
+    },
+  });
+
+  return attachments;
+};

packages/trpc/server/template-router/find-template-attachments.types.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+import { AttachmentType } from '@documenso/prisma/generated/types';
+
+export const ZGetTemplateAttachmentsSchema = z.object({
+  templateId: z.number(),
+});
+
+export const ZGetTemplateAttachmentsResponseSchema = z.array(
+  z.object({
+    id: z.string(),
+    label: z.string(),
+    url: z.string(),
+    type: z.nativeEnum(AttachmentType),
+  }),
+);

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

@@ -29,6 +29,7 @@ import { getPresignPostUrl } from '@documenso/lib/universal/upload/server-action
 
 import { ZGenericSuccessResponse, ZSuccessResponseSchema } from '../document-router/schema';
 import { authenticatedProcedure, maybeAuthenticatedProcedure, router } from '../trpc';
+import { findTemplateAttachmentsRoute } from './find-template-attachments';
 import {
   ZBulkSendTemplateMutationSchema,
   ZCreateDocumentFromDirectTemplateRequestSchema,
@@ -52,8 +53,14 @@ import {
   ZUpdateTemplateRequestSchema,
   ZUpdateTemplateResponseSchema,
 } from './schema';
+import { setTemplateAttachmentsRoute } from './set-template-attachments';
 
 export const templateRouter = router({
+  attachments: {
+    find: findTemplateAttachmentsRoute,
+    set: setTemplateAttachmentsRoute,
+  },
+
   /**
    * @public
    */

packages/trpc/server/template-router/set-template-attachments.ts

@@ -0,0 +1,95 @@
+import type { Attachment } from '@prisma/client';
+
+import { AppError } from '@documenso/lib/errors/app-error';
+import { AppErrorCode } from '@documenso/lib/errors/app-error';
+import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
+import { prisma } from '@documenso/prisma';
+
+import { authenticatedProcedure } from '../trpc';
+import {
+  ZSetTemplateAttachmentsResponseSchema,
+  ZSetTemplateAttachmentsSchema,
+} from './set-template-attachments.types';
+
+export const setTemplateAttachmentsRoute = authenticatedProcedure
+  .input(ZSetTemplateAttachmentsSchema)
+  .output(ZSetTemplateAttachmentsResponseSchema)
+  .mutation(async ({ input, ctx }) => {
+    const { templateId, attachments } = input;
+
+    const updatedAttachments = await setTemplateAttachments({
+      templateId,
+      userId: ctx.user.id,
+      teamId: ctx.teamId,
+      attachments,
+    });
+
+    return updatedAttachments;
+  });
+
+export type CreateAttachmentsOptions = {
+  templateId: number;
+  attachments: Pick<Attachment, 'id' | 'label' | 'url' | 'type'>[];
+  userId: number;
+  teamId: number;
+};
+
+export const setTemplateAttachments = async ({
+  templateId,
+  attachments,
+  userId,
+  teamId,
+}: CreateAttachmentsOptions) => {
+  const template = await prisma.template.findUnique({
+    where: {
+      id: templateId,
+      team: buildTeamWhereQuery({ teamId, userId }),
+    },
+  });
+
+  if (!template) {
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: 'Template not found',
+    });
+  }
+
+  const existingAttachments = await prisma.attachment.findMany({
+    where: {
+      templateId,
+    },
+  });
+
+  const newIds = attachments.map((a) => a.id).filter(Boolean);
+  const toDelete = existingAttachments.filter((existing) => !newIds.includes(existing.id));
+
+  if (toDelete.length > 0) {
+    await prisma.attachment.deleteMany({
+      where: {
+        id: { in: toDelete.map((a) => a.id) },
+      },
+    });
+  }
+
+  const upsertedAttachments: Attachment[] = [];
+
+  for (const attachment of attachments) {
+    const updated = await prisma.attachment.upsert({
+      where: { id: attachment.id, templateId: template.id },
+      update: {
+        label: attachment.label,
+        url: attachment.url,
+        type: attachment.type,
+        templateId,
+      },
+      create: {
+        label: attachment.label,
+        url: attachment.url,
+        type: attachment.type,
+        templateId,
+      },
+    });
+    upsertedAttachments.push(updated);
+  }
+
+  return upsertedAttachments;
+};

packages/trpc/server/template-router/set-template-attachments.types.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+import { AttachmentType } from '@documenso/prisma/generated/types';
+
+export const ZSetTemplateAttachmentsSchema = z.object({
+  templateId: z.number(),
+  attachments: z.array(
+    z.object({
+      id: z.string(),
+      label: z.string().min(1, 'Label is required'),
+      url: z.string().url('Invalid URL'),
+      type: z.nativeEnum(AttachmentType),
+    }),
+  ),
+});
+
+export type TSetTemplateAttachmentsSchema = z.infer<typeof ZSetTemplateAttachmentsSchema>;
+
+export const ZSetTemplateAttachmentsResponseSchema = z.array(
+  z.object({
+    id: z.string(),
+    label: z.string(),
+    url: z.string(),
+    type: z.nativeEnum(AttachmentType),
+  }),
+);