Merge branch 'main' into feat/accept-text-signature

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

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

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

@@ -9,7 +9,9 @@ export const getUsersWithSubscriptionsCount = async () => {
   return await prisma.user.count({
     where: {
       Subscription: {
-        status: SubscriptionStatus.ACTIVE,
+        some: {
+          status: SubscriptionStatus.ACTIVE,
+        },
       },
     },
   });

packages/lib/server-only/document-meta/upsert-document-meta.ts

@@ -6,13 +6,26 @@ export type CreateDocumentMetaOptions = {
   documentId: number;
   subject: string;
   message: string;
+  timezone: string;
+  dateFormat: string;
+  userId: number;
 };
 
 export const upsertDocumentMeta = async ({
   subject,
   message,
+  timezone,
+  dateFormat,
   documentId,
+  userId,
 }: CreateDocumentMetaOptions) => {
+  await prisma.document.findFirstOrThrow({
+    where: {
+      id: documentId,
+      userId,
+    },
+  });
+
   return await prisma.documentMeta.upsert({
     where: {
       documentId,
@@ -20,11 +33,15 @@ export const upsertDocumentMeta = async ({
     create: {
       subject,
       message,
+      dateFormat,
+      timezone,
       documentId,
     },
     update: {
       subject,
       message,
+      dateFormat,
+      timezone,
     },
   });
 };

packages/lib/server-only/document/duplicate-document-by-id.ts

@@ -25,6 +25,8 @@ export const duplicateDocumentById = async ({ id, userId }: DuplicateDocumentByI
         select: {
           message: true,
           subject: true,
+          dateFormat: true,
+          timezone: true,
         },
       },
     },

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/document/get-document-meta-by-document-id.ts

@@ -0,0 +1,13 @@
+import { prisma } from '@documenso/prisma';
+
+export interface GetDocumentMetaByDocumentIdOptions {
+  id: number;
+}
+
+export const getDocumentMetaByDocumentId = async ({ id }: GetDocumentMetaByDocumentIdOptions) => {
+  return await prisma.documentMeta.findFirstOrThrow({
+    where: {
+      documentId: id,
+    },
+  });
+};

packages/lib/server-only/document/update-document.ts

@@ -1,6 +1,6 @@
 'use server';
 
-import { Prisma } from '@prisma/client';
+import type { Prisma } from '@prisma/client';
 
 import { prisma } from '@documenso/prisma';
 

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-document.ts

@@ -1,5 +1,6 @@
 import { prisma } from '@documenso/prisma';
-import { FieldType, SendStatus, SigningStatus } from '@documenso/prisma/client';
+import type { FieldType } from '@documenso/prisma/client';
+import { SendStatus, SigningStatus } from '@documenso/prisma/client';
 
 export interface SetFieldsForDocumentOptions {
   userId: number;

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

@@ -0,0 +1,118 @@
+import { prisma } from '@documenso/prisma';
+import type { 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('Template 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: {
+              templateId_email: {
+                templateId,
+                email: field.signerEmail.toLowerCase(),
+              },
+            },
+          },
+        },
+      }),
+    ),
+  );
+
+  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

@@ -5,6 +5,9 @@ import { DateTime } from 'luxon';
 import { prisma } from '@documenso/prisma';
 import { DocumentStatus, FieldType, SigningStatus } from '@documenso/prisma/client';
 
+import { DEFAULT_DOCUMENT_DATE_FORMAT } from '../../constants/date-formats';
+import { DEFAULT_DOCUMENT_TIME_ZONE } from '../../constants/time-zones';
+
 export type SignFieldWithTokenOptions = {
   token: string;
   fieldId: number;
@@ -33,6 +36,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`);
   }
@@ -54,6 +61,12 @@ export const signFieldWithToken = async ({
     throw new Error(`Field ${fieldId} has no recipientId`);
   }
 
+  const documentMeta = await prisma.documentMeta.findFirst({
+    where: {
+      documentId: document.id,
+    },
+  });
+
   const isSignatureField =
     field.type === FieldType.SIGNATURE || field.type === FieldType.FREE_SIGNATURE;
 
@@ -63,7 +76,9 @@ export const signFieldWithToken = async ({
   const typedSignature = isSignatureField && !isBase64 ? value : undefined;
 
   if (field.type === FieldType.DATE) {
-    customText = DateTime.now().toFormat('yyyy-MM-dd hh:mm a');
+    customText = DateTime.now()
+      .setZone(documentMeta?.timezone ?? DEFAULT_DOCUMENT_TIME_ZONE)
+      .toFormat(documentMeta?.dateFormat ?? DEFAULT_DOCUMENT_DATE_FORMAT);
   }
 
   if (isSignatureField && !signatureImageAsBase64 && !typedSignature) {

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,97 @@
+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(),
+          templateId,
+        },
+      }),
+    ),
+  );
+
+  if (removedRecipients.length > 0) {
+    await prisma.recipient.deleteMany({
+      where: {
+        id: {
+          in: removedRecipients.map((recipient) => recipient.id),
+        },
+      },
+    });
+  }
+
+  return persistedRecipients;
+};

packages/lib/server-only/subscription/get-subscription-by-user-id.ts

@@ -1,15 +0,0 @@
-'use server';
-
-import { prisma } from '@documenso/prisma';
-
-export type GetSubscriptionByUserIdOptions = {
-  userId: number;
-};
-
-export const getSubscriptionByUserId = async ({ userId }: GetSubscriptionByUserIdOptions) => {
-  return await prisma.subscription.findFirst({
-    where: {
-      userId,
-    },
-  });
-};

packages/lib/server-only/subscription/get-subscriptions-by-user-id.ts

@@ -0,0 +1,15 @@
+'use server';
+
+import { prisma } from '@documenso/prisma';
+
+export type GetSubscriptionsByUserIdOptions = {
+  userId: number;
+};
+
+export const getSubscriptionsByUserId = async ({ userId }: GetSubscriptionsByUserIdOptions) => {
+  return await prisma.subscription.findMany({
+    where: {
+      userId,
+    },
+  });
+};

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

@@ -0,0 +1,75 @@
+import { nanoid } from '@documenso/lib/universal/id';
+import { prisma } from '@documenso/prisma';
+import type { 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(),
+        })),
+      },
+    },
+
+    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.email === recipient?.email);
+
+      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,74 @@
+import { nanoid } from '@documenso/lib/universal/id';
+import { prisma } from '@documenso/prisma';
+import type { 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(),
+        })),
+      },
+    },
+
+    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.email === recipient?.email,
+      );
+
+      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,35 @@
+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([
+    prisma.template.findMany({
+      where: {
+        userId,
+      },
+      include: {
+        templateDocumentData: true,
+        Field: true,
+      },
+      skip: Math.max(page - 1, 0) * perPage,
+      orderBy: {
+        createdAt: 'desc',
+      },
+    }),
+    prisma.template.count({
+      where: {
+        userId,
+      },
+    }),
+  ]);
+
+  return {
+    templates,
+    totalPages: Math.ceil(count / perPage),
+  };
+};

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

@@ -1,9 +1,11 @@
 import { hash } from 'bcrypt';
 
+import { getStripeCustomerByUser } from '@documenso/ee/server-only/stripe/get-customer';
 import { prisma } from '@documenso/prisma';
 import { IdentityProvider } from '@documenso/prisma/client';
 
 import { SALT_ROUNDS } from '../../constants/auth';
+import { getFlag } from '../../universal/get-feature-flag';
 
 export interface CreateUserOptions {
   name: string;
@@ -13,6 +15,8 @@ export interface CreateUserOptions {
 }
 
 export const createUser = async ({ name, email, password, signature }: CreateUserOptions) => {
+  const isBillingEnabled = await getFlag('app_billing');
+
   const hashedPassword = await hash(password, SALT_ROUNDS);
 
   const userExists = await prisma.user.findFirst({
@@ -25,7 +29,7 @@ export const createUser = async ({ name, email, password, signature }: CreateUse
     throw new Error('User already exists');
   }
 
-  return await prisma.user.create({
+  let user = await prisma.user.create({
     data: {
       name,
       email: email.toLowerCase(),
@@ -34,4 +38,15 @@ export const createUser = async ({ name, email, password, signature }: CreateUse
       identityProvider: IdentityProvider.DOCUMENSO,
     },
   });
+
+  if (isBillingEnabled) {
+    try {
+      const stripeSession = await getStripeCustomerByUser(user);
+      user = stripeSession.user;
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  return user;
 };