Merge branch 'main' into feat/document-table-filters

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

@@ -1,4 +1,6 @@
-import { DocumentSource, type Prisma, WebhookTriggerEvents } from '@prisma/client';
+import type { Prisma, Recipient } from '@prisma/client';
+import { DocumentSource, WebhookTriggerEvents } from '@prisma/client';
+import { omit } from 'remeda';
 
 import { prisma } from '@documenso/prisma';
 
@@ -7,7 +9,7 @@ import {
   ZWebhookDocumentSchema,
   mapDocumentToWebhookDocumentPayload,
 } from '../../types/webhook-payload';
-import { prefixedId } from '../../universal/id';
+import { nanoid, prefixedId } from '../../universal/id';
 import { triggerWebhook } from '../webhooks/trigger/trigger-webhook';
 import { getDocumentWhereInput } from './get-document-by-id';
 
@@ -40,14 +42,16 @@ export const duplicateDocument = async ({
           type: true,
         },
       },
-      documentMeta: {
+      authOptions: true,
+      visibility: true,
+      documentMeta: true,
+      recipients: {
         select: {
-          message: true,
-          subject: true,
-          dateFormat: true,
-          password: true,
-          timezone: true,
-          redirectUrl: true,
+          email: true,
+          name: true,
+          role: true,
+          signingOrder: true,
+          fields: true,
         },
       },
     },
@@ -59,56 +63,83 @@ export const duplicateDocument = async ({
     });
   }
 
-  const createDocumentArguments: Prisma.DocumentCreateArgs = {
+  const documentData = await prisma.documentData.create({
     data: {
-      title: document.title,
-      qrToken: prefixedId('qr'),
-      user: {
-        connect: {
-          id: document.userId,
-        },
-      },
-      team: {
-        connect: {
-          id: teamId,
-        },
-      },
-      documentData: {
-        create: {
-          ...document.documentData,
-          data: document.documentData.initialData,
-        },
-      },
-      documentMeta: {
-        create: {
-          ...document.documentMeta,
-        },
-      },
-      source: DocumentSource.DOCUMENT,
+      type: document.documentData.type,
+      data: document.documentData.initialData,
+      initialData: document.documentData.initialData,
     },
-  };
+  });
 
-  if (teamId !== undefined) {
-    createDocumentArguments.data.team = {
-      connect: {
-        id: teamId,
+  let documentMeta: Prisma.DocumentCreateArgs['data']['documentMeta'] | undefined = undefined;
+
+  if (document.documentMeta) {
+    documentMeta = {
+      create: {
+        ...omit(document.documentMeta, ['id', 'documentId']),
+        emailSettings: document.documentMeta.emailSettings || undefined,
       },
     };
   }
 
   const createdDocument = await prisma.document.create({
-    ...createDocumentArguments,
+    data: {
+      userId: document.userId,
+      teamId: teamId,
+      title: document.title,
+      documentDataId: documentData.id,
+      authOptions: document.authOptions || undefined,
+      visibility: document.visibility,
+      qrToken: prefixedId('qr'),
+      documentMeta,
+      source: DocumentSource.DOCUMENT,
+    },
     include: {
       recipients: true,
       documentMeta: true,
     },
   });
 
+  const recipientsToCreate = document.recipients.map((recipient) => ({
+    documentId: createdDocument.id,
+    email: recipient.email,
+    name: recipient.name,
+    role: recipient.role,
+    signingOrder: recipient.signingOrder,
+    token: nanoid(),
+    fields: {
+      createMany: {
+        data: recipient.fields.map((field) => ({
+          documentId: createdDocument.id,
+          type: field.type,
+          page: field.page,
+          positionX: field.positionX,
+          positionY: field.positionY,
+          width: field.width,
+          height: field.height,
+          customText: '',
+          inserted: false,
+          fieldMeta: field.fieldMeta as PrismaJson.FieldMeta,
+        })),
+      },
+    },
+  }));
+
+  const recipients: Recipient[] = [];
+
+  for (const recipientData of recipientsToCreate) {
+    const newRecipient = await prisma.recipient.create({
+      data: recipientData,
+    });
+
+    recipients.push(newRecipient);
+  }
+
   await triggerWebhook({
     event: WebhookTriggerEvents.DOCUMENT_CREATED,
     data: ZWebhookDocumentSchema.parse({
       ...mapDocumentToWebhookDocumentPayload(createdDocument),
-      recipients: createdDocument.recipients,
+      recipients,
       documentMeta: createdDocument.documentMeta,
     }),
     userId: userId,

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

@@ -117,7 +117,12 @@ export const sealDocument = async ({
     ? await getCertificatePdf({
         documentId,
         language: document.documentMeta?.language,
-      }).catch(() => null)
+      }).catch((e) => {
+        console.log('Failed to get certificate PDF');
+        console.error(e);
+
+        return null;
+      })
     : null;
 
   const doc = await PDFDocument.load(pdfData);

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

@@ -27,7 +27,6 @@ export const viewedDocument = async ({
   const recipient = await prisma.recipient.findFirst({
     where: {
       token,
-      readStatus: ReadStatus.NOT_OPENED,
     },
   });
 
@@ -37,6 +36,30 @@ export const viewedDocument = async ({
 
   const { documentId } = recipient;
 
+  await prisma.documentAuditLog.create({
+    data: createDocumentAuditLogData({
+      type: DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_VIEWED,
+      documentId,
+      user: {
+        name: recipient.name,
+        email: recipient.email,
+      },
+      requestMetadata,
+      data: {
+        recipientEmail: recipient.email,
+        recipientId: recipient.id,
+        recipientName: recipient.name,
+        recipientRole: recipient.role,
+        accessAuth: recipientAccessAuth ?? [],
+      },
+    }),
+  });
+
+  // Early return if already opened.
+  if (recipient.readStatus === ReadStatus.OPENED) {
+    return;
+  }
+
   await prisma.$transaction(async (tx) => {
     await tx.recipient.update({
       where: {

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

@@ -1,5 +1,6 @@
 import { DocumentStatus, FieldType, RecipientRole, SigningStatus } from '@prisma/client';
 import { DateTime } from 'luxon';
+import { isDeepEqual } from 'remeda';
 import { match } from 'ts-pattern';
 
 import { validateCheckboxField } from '@documenso/lib/advanced-fields-validation/validate-checkbox';
@@ -10,6 +11,7 @@ import { validateTextField } from '@documenso/lib/advanced-fields-validation/val
 import { fromCheckboxValue } from '@documenso/lib/universal/field-checkbox';
 import { prisma } from '@documenso/prisma';
 
+import { AUTO_SIGNABLE_FIELD_TYPES } from '../../constants/autosign';
 import { DEFAULT_DOCUMENT_DATE_FORMAT } from '../../constants/date-formats';
 import { DEFAULT_DOCUMENT_TIME_ZONE } from '../../constants/time-zones';
 import { DOCUMENT_AUDIT_LOG_TYPE } from '../../types/document-audit-logs';
@@ -205,6 +207,29 @@ export const signFieldWithToken = async ({
     throw new Error('Typed signatures are not allowed. Please draw your signature');
   }
 
+  if (field.fieldMeta?.readOnly && !AUTO_SIGNABLE_FIELD_TYPES.includes(field.type)) {
+    // !: This is a bit of a hack at the moment, readonly fields with default values
+    // !: should be inserted with their default value on document creation instead of
+    // !: this weird programattic approach. Until that's fixed though this will verify
+    // !: that the programmatic signed value is only that of its default.
+    const isAutomaticSigningValueValid = match(field.fieldMeta)
+      .with({ type: 'text' }, (meta) => customText === meta.text)
+      .with({ type: 'number' }, (meta) => customText === meta.value)
+      .with({ type: 'checkbox' }, (meta) =>
+        isDeepEqual(
+          fromCheckboxValue(customText ?? ''),
+          meta.values?.filter((v) => v.checked).map((v) => v.value) ?? [],
+        ),
+      )
+      .with({ type: 'radio' }, (meta) => customText === meta.values?.find((v) => v.checked)?.value)
+      .with({ type: 'dropdown' }, (meta) => customText === meta.defaultValue)
+      .otherwise(() => false);
+
+    if (!isAutomaticSigningValueValid) {
+      throw new Error('Field is read only and only accepts its default value for signing.');
+    }
+  }
+
   const assistant = recipient.role === RecipientRole.ASSISTANT ? recipient : undefined;
 
   return await prisma.$transaction(async (tx) => {

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

@@ -23,8 +23,15 @@ export const duplicateTemplate = async ({
       team: buildTeamWhereQuery({ teamId, userId }),
     },
     include: {
-      recipients: true,
-      fields: true,
+      recipients: {
+        select: {
+          email: true,
+          name: true,
+          role: true,
+          signingOrder: true,
+          fields: true,
+        },
+      },
       templateDocumentData: true,
       templateMeta: true,
     },
@@ -59,13 +66,8 @@ export const duplicateTemplate = async ({
       teamId,
       title: template.title + ' (copy)',
       templateDocumentDataId: documentData.id,
-      recipients: {
-        create: template.recipients.map((recipient) => ({
-          email: recipient.email,
-          name: recipient.name,
-          token: nanoid(),
-        })),
-      },
+      authOptions: template.authOptions || undefined,
+      visibility: template.visibility,
       templateMeta,
     },
     include: {
@@ -73,32 +75,36 @@ export const duplicateTemplate = async ({
     },
   });
 
-  await prisma.field.createMany({
-    data: template.fields.map((field) => {
-      const recipient = template.recipients.find((recipient) => recipient.id === field.recipientId);
+  const recipientsToCreate = template.recipients.map((recipient) => ({
+    templateId: duplicatedTemplate.id,
+    email: recipient.email,
+    name: recipient.name,
+    role: recipient.role,
+    signingOrder: recipient.signingOrder,
+    token: nanoid(),
+    fields: {
+      createMany: {
+        data: recipient.fields.map((field) => ({
+          templateId: duplicatedTemplate.id,
+          type: field.type,
+          page: field.page,
+          positionX: field.positionX,
+          positionY: field.positionY,
+          width: field.width,
+          height: field.height,
+          customText: '',
+          inserted: false,
+          fieldMeta: field.fieldMeta as PrismaJson.FieldMeta,
+        })),
+      },
+    },
+  }));
 
-      const duplicatedTemplateRecipient = duplicatedTemplate.recipients.find(
-        (doc) => doc.email === recipient?.email,
-      );
-
-      if (!duplicatedTemplateRecipient) {
-        throw new Error('Recipient not found.');
-      }
-
-      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,
-      };
-    }),
-  });
+  for (const recipientData of recipientsToCreate) {
+    await prisma.recipient.create({
+      data: recipientData,
+    });
+  }
 
   return duplicatedTemplate;
 };