feat: templates

packages/lib/server-only/admin/get-recipients-stats.ts

@@ -19,9 +19,10 @@ export const getRecipientsStats = async () => {
 
   results.forEach((result) => {
     const { readStatus, signingStatus, sendStatus, _count } = result;
-    stats[readStatus] += _count;
-    stats[signingStatus] += _count;
-    stats[sendStatus] += _count;
+    stats[readStatus as keyof typeof stats] += _count;
+    stats.TOTAL_RECIPIENTS += _count;
+    stats[signingStatus as keyof typeof stats] += _count;
+    stats[sendStatus as keyof typeof stats] += _count;
     stats.TOTAL_RECIPIENTS += _count;
   });
 

packages/lib/server-only/document/find-documents.ts

@@ -8,7 +8,7 @@ import { ExtendedDocumentStatus } from '@documenso/prisma/types/extended-documen
 
 import type { FindResultSet } from '../../types/find-result-set';
 
-export interface FindDocumentsOptions {
+export type FindDocumentsOptions = {
   userId: number;
   term?: string;
   status?: ExtendedDocumentStatus;
@@ -19,7 +19,7 @@ export interface FindDocumentsOptions {
     direction: 'asc' | 'desc';
   };
   period?: '' | '7d' | '14d' | '30d';
-}
+};
 
 export const findDocuments = async ({
   userId,

packages/lib/server-only/field/get-fields-for-template.ts

@@ -0,0 +1,22 @@
+import { prisma } from '@documenso/prisma';
+
+export interface GetFieldsForTemplateOptions {
+  templateId: number;
+  userId: number;
+}
+
+export const getFieldsForTemplate = async ({ templateId, userId }: GetFieldsForTemplateOptions) => {
+  const fields = await prisma.field.findMany({
+    where: {
+      templateId,
+      Template: {
+        userId,
+      },
+    },
+    orderBy: {
+      id: 'asc',
+    },
+  });
+
+  return fields;
+};

packages/lib/server-only/field/remove-signed-field-with-token.ts

@@ -27,6 +27,10 @@ export const removeSignedFieldWithToken = async ({
 
   const { Document: document, Recipient: recipient } = field;
 
+  if (!document) {
+    throw new Error(`Document not found for field ${field.id}`);
+  }
+
   if (document.status === DocumentStatus.COMPLETED) {
     throw new Error(`Document ${document.id} has already been completed`);
   }

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

@@ -0,0 +1,116 @@
+import { prisma } from '@documenso/prisma';
+import { FieldType } from '@documenso/prisma/client';
+
+export type Field = {
+  id?: number | null;
+  type: FieldType;
+  signerEmail: string;
+  signerId?: number;
+  pageNumber: number;
+  pageX: number;
+  pageY: number;
+  pageWidth: number;
+  pageHeight: number;
+};
+
+export type SetFieldsForTemplateOptions = {
+  userId: number;
+  templateId: number;
+  fields: Field[];
+};
+
+export const setFieldsForTemplate = async ({
+  userId,
+  templateId,
+  fields,
+}: SetFieldsForTemplateOptions) => {
+  const template = await prisma.template.findFirst({
+    where: {
+      id: templateId,
+      userId,
+    },
+  });
+
+  if (!template) {
+    throw new Error('Document not found');
+  }
+
+  const existingFields = await prisma.field.findMany({
+    where: {
+      templateId,
+    },
+    include: {
+      Recipient: true,
+    },
+  });
+
+  const removedFields = existingFields.filter(
+    (existingField) =>
+      !fields.find(
+        (field) =>
+          field.id === existingField.id || field.signerEmail === existingField.Recipient?.email,
+      ),
+  );
+
+  const linkedFields = fields.map((field) => {
+    const existing = existingFields.find((existingField) => existingField.id === field.id);
+
+    return {
+      ...field,
+      _persisted: existing,
+    };
+  });
+
+  const persistedFields = await prisma.$transaction(
+    // Disabling as wrapping promises here causes type issues
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    linkedFields.map((field) =>
+      prisma.field.upsert({
+        where: {
+          id: field._persisted?.id ?? -1,
+          templateId,
+        },
+        update: {
+          page: field.pageNumber,
+          positionX: field.pageX,
+          positionY: field.pageY,
+          width: field.pageWidth,
+          height: field.pageHeight,
+        },
+        create: {
+          type: field.type,
+          page: field.pageNumber,
+          positionX: field.pageX,
+          positionY: field.pageY,
+          width: field.pageWidth,
+          height: field.pageHeight,
+          customText: '',
+          inserted: false,
+          Template: {
+            connect: {
+              id: templateId,
+            },
+          },
+          Recipient: {
+            connect: {
+              id: field.signerId,
+              email: field.signerEmail,
+            },
+          },
+        },
+      }),
+    ),
+  );
+
+  if (removedFields.length > 0) {
+    await prisma.field.deleteMany({
+      where: {
+        id: {
+          in: removedFields.map((field) => field.id),
+        },
+      },
+    });
+  }
+
+  return persistedFields;
+};

packages/lib/server-only/field/sign-field-with-token.ts

@@ -33,6 +33,10 @@ export const signFieldWithToken = async ({
 
   const { Document: document, Recipient: recipient } = field;
 
+  if (!document) {
+    throw new Error(`Document not found for field ${field.id}`);
+  }
+
   if (document.status === DocumentStatus.COMPLETED) {
     throw new Error(`Document ${document.id} has already been completed`);
   }

packages/lib/server-only/recipient/get-recipients-for-template.ts

@@ -0,0 +1,25 @@
+import { prisma } from '@documenso/prisma';
+
+export interface GetRecipientsForTemplateOptions {
+  templateId: number;
+  userId: number;
+}
+
+export const getRecipientsForTemplate = async ({
+  templateId,
+  userId,
+}: GetRecipientsForTemplateOptions) => {
+  const recipients = await prisma.recipient.findMany({
+    where: {
+      templateId,
+      Template: {
+        userId,
+      },
+    },
+    orderBy: {
+      id: 'asc',
+    },
+  });
+
+  return recipients;
+};

packages/lib/server-only/recipient/set-recipients-for-template.ts

@@ -0,0 +1,98 @@
+import { prisma } from '@documenso/prisma';
+
+import { nanoid } from '../../universal/id';
+
+export type SetRecipientsForTemplateOptions = {
+  userId: number;
+  templateId: number;
+  recipients: {
+    id?: number;
+    email: string;
+    name: string;
+  }[];
+};
+
+export const setRecipientsForTemplate = async ({
+  userId,
+  templateId,
+  recipients,
+}: SetRecipientsForTemplateOptions) => {
+  const template = await prisma.template.findFirst({
+    where: {
+      id: templateId,
+      userId,
+    },
+  });
+
+  if (!template) {
+    throw new Error('Template not found');
+  }
+
+  const normalizedRecipients = recipients.map((recipient) => ({
+    ...recipient,
+    email: recipient.email.toLowerCase(),
+  }));
+
+  const existingRecipients = await prisma.recipient.findMany({
+    where: {
+      templateId,
+    },
+  });
+
+  const removedRecipients = existingRecipients.filter(
+    (existingRecipient) =>
+      !normalizedRecipients.find(
+        (recipient) =>
+          recipient.id === existingRecipient.id || recipient.email === existingRecipient.email,
+      ),
+  );
+
+  const linkedRecipients = normalizedRecipients.map((recipient) => {
+    const existing = existingRecipients.find(
+      (existingRecipient) =>
+        existingRecipient.id === recipient.id || existingRecipient.email === recipient.email,
+    );
+
+    return {
+      ...recipient,
+      _persisted: existing,
+    };
+  });
+
+  const persistedRecipients = await prisma.$transaction(
+    // Disabling as wrapping promises here causes type issues
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    linkedRecipients.map((recipient) =>
+      prisma.recipient.upsert({
+        where: {
+          id: recipient._persisted?.id ?? -1,
+          templateId,
+        },
+        update: {
+          name: recipient.name,
+          email: recipient.email,
+          templateId,
+        },
+        create: {
+          name: recipient.name,
+          email: recipient.email,
+          token: nanoid(),
+          templateToken: nanoid(),
+          templateId,
+        },
+      }),
+    ),
+  );
+
+  if (removedRecipients.length > 0) {
+    await prisma.recipient.deleteMany({
+      where: {
+        id: {
+          in: removedRecipients.map((recipient) => recipient.id),
+        },
+      },
+    });
+  }
+
+  return persistedRecipients;
+};

packages/lib/server-only/template/create-document-from-template.ts

@@ -0,0 +1,78 @@
+import { nanoid } from '@documenso/lib/universal/id';
+import { prisma } from '@documenso/prisma';
+import { TCreateDocumentFromTemplateMutationSchema } from '@documenso/trpc/server/template-router/schema';
+
+export type CreateDocumentFromTemplateOptions = TCreateDocumentFromTemplateMutationSchema & {
+  userId: number;
+};
+
+export const createDocumentFromTemplate = async ({
+  templateId,
+  userId,
+}: CreateDocumentFromTemplateOptions) => {
+  const template = await prisma.template.findUnique({
+    where: { id: templateId, userId },
+    include: {
+      Recipient: true,
+      Field: true,
+      templateDocumentData: true,
+    },
+  });
+
+  if (!template) {
+    throw new Error('Template not found.');
+  }
+
+  const documentData = await prisma.documentData.create({
+    data: {
+      type: template.templateDocumentData.type,
+      data: template.templateDocumentData.data,
+      initialData: template.templateDocumentData.initialData,
+    },
+  });
+
+  const document = await prisma.document.create({
+    data: {
+      userId,
+      title: template.title,
+      documentDataId: documentData.id,
+      Recipient: {
+        create: template.Recipient.map((recipient) => ({
+          email: recipient.email,
+          name: recipient.name,
+          token: nanoid(),
+          templateToken: recipient.templateToken,
+        })),
+      },
+    },
+
+    include: {
+      Recipient: true,
+    },
+  });
+
+  await prisma.field.createMany({
+    data: template.Field.map((field) => {
+      const recipient = template.Recipient.find((recipient) => recipient.id === field.recipientId);
+
+      const documentRecipient = document.Recipient.find(
+        (doc) => doc.templateToken === recipient?.templateToken,
+      );
+
+      return {
+        type: field.type,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
+        width: field.width,
+        height: field.height,
+        customText: field.customText,
+        inserted: field.inserted,
+        documentId: document.id,
+        recipientId: documentRecipient?.id || null,
+      };
+    }),
+  });
+
+  return document;
+};

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

@@ -0,0 +1,20 @@
+import { prisma } from '@documenso/prisma';
+import { TCreateTemplateMutationSchema } from '@documenso/trpc/server/template-router/schema';
+
+export type CreateTemplateOptions = TCreateTemplateMutationSchema & {
+  userId: number;
+};
+
+export const createTemplate = async ({
+  title,
+  userId,
+  templateDocumentDataId,
+}: CreateTemplateOptions) => {
+  return await prisma.template.create({
+    data: {
+      title,
+      userId,
+      templateDocumentDataId,
+    },
+  });
+};

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

@@ -0,0 +1,12 @@
+'use server';
+
+import { prisma } from '@documenso/prisma';
+
+export type DeleteTemplateOptions = {
+  id: number;
+  userId: number;
+};
+
+export const deleteTemplate = async ({ id, userId }: DeleteTemplateOptions) => {
+  return await prisma.template.delete({ where: { id, userId } });
+};

packages/lib/server-only/template/duplicate-template.ts

@@ -0,0 +1,75 @@
+import { nanoid } from '@documenso/lib/universal/id';
+import { prisma } from '@documenso/prisma';
+import { TDuplicateTemplateMutationSchema } from '@documenso/trpc/server/template-router/schema';
+
+export type DuplicateTemplateOptions = TDuplicateTemplateMutationSchema & {
+  userId: number;
+};
+
+export const duplicateTemplate = async ({ templateId, userId }: DuplicateTemplateOptions) => {
+  const template = await prisma.template.findUnique({
+    where: { id: templateId, userId },
+    include: {
+      Recipient: true,
+      Field: true,
+      templateDocumentData: true,
+    },
+  });
+
+  if (!template) {
+    throw new Error('Template not found.');
+  }
+
+  const documentData = await prisma.documentData.create({
+    data: {
+      type: template.templateDocumentData.type,
+      data: template.templateDocumentData.data,
+      initialData: template.templateDocumentData.initialData,
+    },
+  });
+
+  const duplicatedTemplate = await prisma.template.create({
+    data: {
+      userId,
+      title: template.title + ' (copy)',
+      templateDocumentDataId: documentData.id,
+      Recipient: {
+        create: template.Recipient.map((recipient) => ({
+          email: recipient.email,
+          name: recipient.name,
+          token: nanoid(),
+          templateToken: recipient.templateToken,
+        })),
+      },
+    },
+
+    include: {
+      Recipient: true,
+    },
+  });
+
+  await prisma.field.createMany({
+    data: template.Field.map((field) => {
+      const recipient = template.Recipient.find((recipient) => recipient.id === field.recipientId);
+
+      const duplicatedTemplateRecipient = duplicatedTemplate.Recipient.find(
+        (doc) => doc.templateToken === recipient?.templateToken,
+      );
+
+      return {
+        type: field.type,
+        page: field.page,
+        positionX: field.positionX,
+        positionY: field.positionY,
+        width: field.width,
+        height: field.height,
+        customText: field.customText,
+        inserted: field.inserted,
+        templateId: duplicatedTemplate.id,
+        recipientId: duplicatedTemplateRecipient?.id || null,
+      };
+    }),
+  });
+
+  return duplicatedTemplate;
+};

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

@@ -0,0 +1,18 @@
+import { prisma } from '@documenso/prisma';
+
+export interface GetTemplateByIdOptions {
+  id: number;
+  userId: number;
+}
+
+export const getTemplateById = async ({ id, userId }: GetTemplateByIdOptions) => {
+  return await prisma.template.findFirstOrThrow({
+    where: {
+      id,
+      userId,
+    },
+    include: {
+      templateDocumentData: true,
+    },
+  });
+};

packages/lib/server-only/template/get-templates.ts

@@ -0,0 +1,37 @@
+import { prisma } from '@documenso/prisma';
+
+export type GetTemplatesOptions = {
+  userId: number;
+  page: number;
+  perPage: number;
+};
+
+export const getTemplates = async ({ userId, page = 1, perPage = 10 }: GetTemplatesOptions) => {
+  const [templates, count] = await Promise.all([
+    await prisma.template.findMany({
+      where: {
+        userId,
+      },
+      include: {
+        templateDocumentData: true,
+        Field: true,
+      },
+      skip: Math.max(page - 1, 0) * perPage,
+      orderBy: {
+        createdAt: 'desc',
+      },
+    }),
+    await prisma.template.count({
+      where: {
+        User: {
+          id: userId,
+        },
+      },
+    }),
+  ]);
+
+  return {
+    templates,
+    totalPages: Math.ceil(count / perPage),
+  };
+};