Merge branch 'feat/rr7' into chore/webhook-trigger-multiselect

packages/api/hono.ts

@@ -1,4 +1,4 @@
-import { fetchRequestHandler } from '@ts-rest/serverless/fetch';
+import { TsRestHttpError, fetchRequestHandler } from '@ts-rest/serverless/fetch';
 import { Hono } from 'hono';
 
 import { ApiContractV1 } from '@documenso/api/v1/contract';
@@ -18,8 +18,7 @@ tsRestHonoApp
   .get('/openapi.json', (c) => c.json(OpenAPIV1))
   .get('/me', async (c) => testCredentialsHandler(c.req.raw));
 
-// Zapier. Todo: Check methods. Are these get/post/update requests?
-// Todo: Is there really no validations?
+// Zapier. Todo: (RR7) Check methods. Are these get/post/update requests?
 tsRestHonoApp
   .all('/zapier/list-documents', async (c) => listDocumentsHandler(c.req.raw))
   .all('/zapier/subscribe', async (c) => subscribeHandler(c.req.raw))
@@ -30,6 +29,12 @@ tsRestHonoApp.mount('/', async (request) => {
     request,
     contract: ApiContractV1,
     router: ApiContractV1Implementation,
-    options: {},
+    options: {
+      errorHandler: (err) => {
+        if (err instanceof TsRestHttpError && err.statusCode === 500) {
+          console.error(err);
+        }
+      },
+    },
   });
 });

packages/api/v1/implementation.ts

@@ -1,3 +1,5 @@
+import type { Prisma } from '@prisma/client';
+import { DocumentDataType, SigningStatus, TeamMemberRole } from '@prisma/client';
 import { tsr } from '@ts-rest/serverless/fetch';
 import { match } from 'ts-pattern';
 
@@ -48,15 +50,9 @@ import {
   getPresignGetUrl,
   getPresignPostUrl,
 } from '@documenso/lib/universal/upload/server-actions';
+import { isDocumentCompleted } from '@documenso/lib/utils/document';
 import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
 import { prisma } from '@documenso/prisma';
-import type { Prisma } from '@documenso/prisma/client';
-import {
-  DocumentDataType,
-  DocumentStatus,
-  SigningStatus,
-  TeamMemberRole,
-} from '@documenso/prisma/client';
 
 import { ApiContractV1 } from './contract';
 import { authenticatedMiddleware } from './middleware/authenticated';
@@ -181,7 +177,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
         };
       }
 
-      if (document.status !== DocumentStatus.COMPLETED) {
+      if (!isDocumentCompleted(document.status)) {
         return {
           status: 400,
           body: {
@@ -329,6 +325,8 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
         signingOrder: body.meta.signingOrder,
         language: body.meta.language,
         typedSignatureEnabled: body.meta.typedSignatureEnabled,
+        uploadSignatureEnabled: body.meta.uploadSignatureEnabled,
+        drawSignatureEnabled: body.meta.drawSignatureEnabled,
         distributionMethod: body.meta.distributionMethod,
         emailSettings: body.meta.emailSettings,
         requestMetadata: metadata,
@@ -585,6 +583,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
         userId: user.id,
         teamId: team?.id,
         recipients: body.recipients,
+        prefillFields: body.prefillFields,
         override: {
           title: body.title,
           ...body.meta,
@@ -673,7 +672,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
         };
       }
 
-      if (document.status === DocumentStatus.COMPLETED) {
+      if (isDocumentCompleted(document.status)) {
         return {
           status: 400,
           body: {
@@ -776,7 +775,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    if (document.status === DocumentStatus.COMPLETED) {
+    if (isDocumentCompleted(document.status)) {
       return {
         status: 400,
         body: {
@@ -867,7 +866,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    if (document.status === DocumentStatus.COMPLETED) {
+    if (isDocumentCompleted(document.status)) {
       return {
         status: 400,
         body: {
@@ -926,7 +925,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    if (document.status === DocumentStatus.COMPLETED) {
+    if (isDocumentCompleted(document.status)) {
       return {
         status: 400,
         body: {
@@ -991,7 +990,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    if (document.status === DocumentStatus.COMPLETED) {
+    if (isDocumentCompleted(document.status)) {
       return {
         status: 400,
         body: { message: 'Document is already completed' },
@@ -1153,7 +1152,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    if (document.status === DocumentStatus.COMPLETED) {
+    if (isDocumentCompleted(document.status)) {
       return {
         status: 400,
         body: {
@@ -1241,7 +1240,7 @@ export const ApiContractV1Implementation = tsr.router(ApiContractV1, {
       };
     }
 
-    if (document.status === DocumentStatus.COMPLETED) {
+    if (isDocumentCompleted(document.status)) {
       return {
         status: 400,
         body: {

packages/api/v1/middleware/authenticated.ts

@@ -1,10 +1,10 @@
+import type { Team, User } from '@prisma/client';
 import type { TsRestRequest } from '@ts-rest/serverless';
 
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { getApiTokenByToken } from '@documenso/lib/server-only/public-api/get-api-token-by-token';
 import type { ApiRequestMetadata } from '@documenso/lib/universal/extract-request-metadata';
 import { extractRequestMetadata } from '@documenso/lib/universal/extract-request-metadata';
-import type { Team, User } from '@documenso/prisma/client';
 
 type B = {
   // appRoute: any;
@@ -52,7 +52,7 @@ export const authenticatedMiddleware = <
       }
 
       const metadata: ApiRequestMetadata = {
-        requestMetadata: extractRequestMetadata(request), // Todo: Test
+        requestMetadata: extractRequestMetadata(request),
         source: 'apiV1',
         auth: 'api',
         auditUser: {

packages/api/v1/openapi.ts

@@ -1,5 +1,7 @@
 import { generateOpenApi } from '@ts-rest/open-api';
 
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+
 import { ApiContractV1 } from './contract';
 
 export const OpenAPIV1 = Object.assign(
@@ -11,6 +13,11 @@ export const OpenAPIV1 = Object.assign(
         version: '1.0.0',
         description: 'The Documenso API for retrieving, creating, updating and deleting documents.',
       },
+      servers: [
+        {
+          url: NEXT_PUBLIC_WEBAPP_URL(),
+        },
+      ],
     },
     {
       setOperationId: true,

packages/api/v1/schema.ts

@@ -1,4 +1,16 @@
 import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import {
+  DocumentDataType,
+  DocumentDistributionMethod,
+  DocumentSigningOrder,
+  FieldType,
+  ReadStatus,
+  RecipientRole,
+  SendStatus,
+  SigningStatus,
+  TeamMemberRole,
+  TemplateType,
+} from '@prisma/client';
 import { z } from 'zod';
 
 import { DATE_FORMATS, DEFAULT_DOCUMENT_DATE_FORMAT } from '@documenso/lib/constants/date-formats';
@@ -11,19 +23,7 @@ import {
   ZRecipientActionAuthTypesSchema,
 } from '@documenso/lib/types/document-auth';
 import { ZDocumentEmailSettingsSchema } from '@documenso/lib/types/document-email';
-import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
-import {
-  DocumentDataType,
-  DocumentDistributionMethod,
-  DocumentSigningOrder,
-  FieldType,
-  ReadStatus,
-  RecipientRole,
-  SendStatus,
-  SigningStatus,
-  TeamMemberRole,
-  TemplateType,
-} from '@documenso/prisma/client';
+import { ZFieldMetaPrefillFieldsSchema, ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
 
 extendZodWithOpenApi(z);
 
@@ -96,7 +96,7 @@ export const ZSendDocumentForSigningMutationSchema = z
         'Whether to send completion emails when the document is fully signed. This will override the document email settings.',
     }),
   })
-  .or(z.literal('').transform(() => ({ sendEmail: true, sendCompletionEmails: undefined })));
+  .or(z.any().transform(() => ({ sendEmail: true, sendCompletionEmails: undefined })));
 
 export type TSendDocumentForSigningMutationSchema = typeof ZSendDocumentForSigningMutationSchema;
 
@@ -157,6 +157,8 @@ export const ZCreateDocumentMutationSchema = z.object({
       signingOrder: z.nativeEnum(DocumentSigningOrder).optional(),
       language: z.enum(SUPPORTED_LANGUAGE_CODES).optional(),
       typedSignatureEnabled: z.boolean().optional().default(true),
+      uploadSignatureEnabled: z.boolean().optional().default(true),
+      drawSignatureEnabled: z.boolean().optional().default(true),
       distributionMethod: z.nativeEnum(DocumentDistributionMethod).optional(),
       emailSettings: ZDocumentEmailSettingsSchema.optional(),
     })
@@ -288,6 +290,8 @@ export const ZGenerateDocumentFromTemplateMutationSchema = z.object({
       language: z.enum(SUPPORTED_LANGUAGE_CODES),
       distributionMethod: z.nativeEnum(DocumentDistributionMethod),
       typedSignatureEnabled: z.boolean(),
+      uploadSignatureEnabled: z.boolean(),
+      drawSignatureEnabled: z.boolean(),
       emailSettings: ZDocumentEmailSettingsSchema,
     })
     .partial()
@@ -299,6 +303,7 @@ export const ZGenerateDocumentFromTemplateMutationSchema = z.object({
     })
     .optional(),
   formValues: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional(),
+  prefillFields: z.array(ZFieldMetaPrefillFieldsSchema).optional(),
 });
 
 export type TGenerateDocumentFromTemplateMutationSchema = z.infer<

packages/app-tests/e2e/api/v1/team-user-management.spec.ts

@@ -1,4 +1,5 @@
 import { expect, test } from '@playwright/test';
+import { TeamMemberRole } from '@prisma/client';
 
 import {
   ZFindTeamMembersResponseSchema,
@@ -10,7 +11,6 @@ import {
 import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
 import { createApiToken } from '@documenso/lib/server-only/public-api/create-api-token';
 import { prisma } from '@documenso/prisma';
-import { TeamMemberRole } from '@documenso/prisma/client';
 import { seedTeam } from '@documenso/prisma/seed/teams';
 import { seedUser } from '@documenso/prisma/seed/users';
 

packages/app-tests/e2e/api/v1/template-field-prefill.spec.ts

@@ -0,0 +1,614 @@
+import { expect, test } from '@playwright/test';
+
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+import { createApiToken } from '@documenso/lib/server-only/public-api/create-api-token';
+import type { TCheckboxFieldMeta, TRadioFieldMeta } from '@documenso/lib/types/field-meta';
+import { prisma } from '@documenso/prisma';
+import { FieldType, RecipientRole } from '@documenso/prisma/client';
+import { seedBlankTemplate } from '@documenso/prisma/seed/templates';
+import { seedUser } from '@documenso/prisma/seed/users';
+
+import { apiSignin } from '../../fixtures/authentication';
+
+const WEBAPP_BASE_URL = NEXT_PUBLIC_WEBAPP_URL();
+
+test.describe('Template Field Prefill API v1', () => {
+  test('should create a document from template with prefilled fields', async ({
+    page,
+    request,
+  }) => {
+    // 1. Create a user
+    const user = await seedUser();
+
+    // 2. Create an API token for the user
+    const { token } = await createApiToken({
+      userId: user.id,
+      tokenName: 'test-token',
+      expiresIn: null,
+    });
+
+    // 3. Create a template with seedBlankTemplate
+    const template = await seedBlankTemplate(user, {
+      createTemplateOptions: {
+        title: 'Template with Advanced Fields',
+      },
+    });
+
+    // 4. Create a recipient for the template
+    const recipient = await prisma.recipient.create({
+      data: {
+        templateId: template.id,
+        email: 'recipient@example.com',
+        name: 'Test Recipient',
+        role: RecipientRole.SIGNER,
+        token: 'test-token',
+        readStatus: 'NOT_OPENED',
+        sendStatus: 'NOT_SENT',
+        signingStatus: 'NOT_SIGNED',
+      },
+    });
+
+    // 5. Add fields to the template
+    // Add TEXT field
+    const textField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.TEXT,
+        page: 1,
+        positionX: 5,
+        positionY: 5,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'text',
+          label: 'Text Field',
+        },
+      },
+    });
+
+    // Add NUMBER field
+    const numberField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.NUMBER,
+        page: 1,
+        positionX: 5,
+        positionY: 15,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'number',
+          label: 'Number Field',
+        },
+      },
+    });
+
+    // Add RADIO field
+    const radioField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.RADIO,
+        page: 1,
+        positionX: 5,
+        positionY: 25,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'radio',
+          label: 'Radio Field',
+          values: [
+            { id: 1, value: 'Option A', checked: false },
+            { id: 2, value: 'Option B', checked: false },
+          ],
+        },
+      },
+    });
+
+    // Add CHECKBOX field
+    const checkboxField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.CHECKBOX,
+        page: 1,
+        positionX: 5,
+        positionY: 35,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'checkbox',
+          label: 'Checkbox Field',
+          values: [
+            { id: 1, value: 'Check A', checked: false },
+            { id: 2, value: 'Check B', checked: false },
+          ],
+        },
+      },
+    });
+
+    // Add DROPDOWN field
+    const dropdownField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.DROPDOWN,
+        page: 1,
+        positionX: 5,
+        positionY: 45,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'dropdown',
+          label: 'Dropdown Field',
+          values: [{ value: 'Select A' }, { value: 'Select B' }],
+        },
+      },
+    });
+
+    // 6. Sign in as the user
+    await apiSignin({
+      page,
+      email: user.email,
+    });
+
+    // 7. Navigate to the template
+    await page.goto(`${WEBAPP_BASE_URL}/templates/${template.id}`);
+
+    // 8. Create a document from the template with prefilled fields
+    const response = await request.post(
+      `${WEBAPP_BASE_URL}/api/v1/templates/${template.id}/generate-document`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        data: {
+          title: 'Document with Prefilled Fields',
+          recipients: [
+            {
+              id: recipient.id,
+              email: 'recipient@example.com',
+              name: 'Test Recipient',
+              role: 'SIGNER',
+            },
+          ],
+          prefillFields: [
+            {
+              id: textField.id,
+              type: 'text',
+              label: 'Prefilled Text',
+              value: 'This is prefilled text',
+            },
+            {
+              id: numberField.id,
+              type: 'number',
+              label: 'Prefilled Number',
+              value: '42',
+            },
+            {
+              id: radioField.id,
+              type: 'radio',
+              label: 'Prefilled Radio',
+              value: 'Option A',
+            },
+            {
+              id: checkboxField.id,
+              type: 'checkbox',
+              label: 'Prefilled Checkbox',
+              value: ['Check A', 'Check B'],
+            },
+            {
+              id: dropdownField.id,
+              type: 'dropdown',
+              label: 'Prefilled Dropdown',
+              value: 'Select B',
+            },
+          ],
+        },
+      },
+    );
+    const responseData = await response.json();
+
+    expect(response.ok()).toBeTruthy();
+    expect(response.status()).toBe(200);
+
+    expect(responseData.documentId).toBeDefined();
+
+    // 9. Verify the document was created with prefilled fields
+    const document = await prisma.document.findUnique({
+      where: {
+        id: responseData.documentId,
+      },
+      include: {
+        fields: true,
+      },
+    });
+
+    expect(document).not.toBeNull();
+
+    // 10. Verify each field has the correct prefilled values
+    const documentTextField = document?.fields.find(
+      (field) => field.type === FieldType.TEXT && field.fieldMeta?.type === 'text',
+    );
+    expect(documentTextField?.fieldMeta).toMatchObject({
+      type: 'text',
+      label: 'Prefilled Text',
+      text: 'This is prefilled text',
+    });
+
+    const documentNumberField = document?.fields.find(
+      (field) => field.type === FieldType.NUMBER && field.fieldMeta?.type === 'number',
+    );
+    expect(documentNumberField?.fieldMeta).toMatchObject({
+      type: 'number',
+      label: 'Prefilled Number',
+      value: '42',
+    });
+
+    const documentRadioField = document?.fields.find(
+      (field) => field.type === FieldType.RADIO && field.fieldMeta?.type === 'radio',
+    );
+    expect(documentRadioField?.fieldMeta).toMatchObject({
+      type: 'radio',
+      label: 'Prefilled Radio',
+    });
+    // Check that the correct radio option is selected
+    const radioValues = (documentRadioField?.fieldMeta as TRadioFieldMeta)?.values || [];
+    const selectedRadioOption = radioValues.find((option) => option.checked);
+    expect(selectedRadioOption?.value).toBe('Option A');
+
+    const documentCheckboxField = document?.fields.find(
+      (field) => field.type === FieldType.CHECKBOX && field.fieldMeta?.type === 'checkbox',
+    );
+    expect(documentCheckboxField?.fieldMeta).toMatchObject({
+      type: 'checkbox',
+      label: 'Prefilled Checkbox',
+    });
+    // Check that the correct checkbox options are selected
+    const checkboxValues = (documentCheckboxField?.fieldMeta as TCheckboxFieldMeta)?.values || [];
+    const checkedOptions = checkboxValues.filter((option) => option.checked);
+    expect(checkedOptions.length).toBe(2);
+    expect(checkedOptions.map((option) => option.value)).toContain('Check A');
+    expect(checkedOptions.map((option) => option.value)).toContain('Check B');
+
+    const documentDropdownField = document?.fields.find(
+      (field) => field.type === FieldType.DROPDOWN && field.fieldMeta?.type === 'dropdown',
+    );
+    expect(documentDropdownField?.fieldMeta).toMatchObject({
+      type: 'dropdown',
+      label: 'Prefilled Dropdown',
+      defaultValue: 'Select B',
+    });
+
+    // 11. Sign in as the recipient and verify the prefilled fields are visible
+    const documentRecipient = await prisma.recipient.findFirst({
+      where: {
+        documentId: document?.id,
+        email: 'recipient@example.com',
+      },
+    });
+
+    // Send the document to the recipient
+    const sendResponse = await request.post(
+      `${WEBAPP_BASE_URL}/api/v1/documents/${document?.id}/send`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        data: {
+          sendEmail: false,
+        },
+      },
+    );
+
+    expect(sendResponse.ok()).toBeTruthy();
+    expect(sendResponse.status()).toBe(200);
+
+    expect(documentRecipient).not.toBeNull();
+
+    // Visit the signing page
+    await page.goto(`${WEBAPP_BASE_URL}/sign/${documentRecipient?.token}`);
+
+    // Verify the prefilled fields are visible with correct values
+    // Text field
+    await expect(page.getByText('This is prefilled')).toBeVisible();
+
+    // Number field
+    await expect(page.getByText('42')).toBeVisible();
+
+    // Radio field
+    await expect(page.getByText('Option A')).toBeVisible();
+    await expect(page.getByRole('radio', { name: 'Option A' })).toBeChecked();
+
+    // Checkbox field
+    await expect(page.getByText('Check A')).toBeVisible();
+    await expect(page.getByText('Check B')).toBeVisible();
+    await expect(page.getByRole('checkbox', { name: 'Check A' })).toBeChecked();
+    await expect(page.getByRole('checkbox', { name: 'Check B' })).toBeChecked();
+
+    // Dropdown field
+    await expect(page.getByText('Select B')).toBeVisible();
+  });
+
+  test('should create a document from template without prefilled fields', async ({
+    page,
+    request,
+  }) => {
+    // 1. Create a user
+    const user = await seedUser();
+
+    // 2. Create an API token for the user
+    const { token } = await createApiToken({
+      userId: user.id,
+      tokenName: 'test-token',
+      expiresIn: null,
+    });
+
+    // 3. Create a template with seedBlankTemplate
+    const template = await seedBlankTemplate(user, {
+      createTemplateOptions: {
+        title: 'Template with Default Fields',
+      },
+    });
+
+    // 4. Create a recipient for the template
+    const recipient = await prisma.recipient.create({
+      data: {
+        templateId: template.id,
+        email: 'recipient@example.com',
+        name: 'Test Recipient',
+        role: RecipientRole.SIGNER,
+        token: 'test-token',
+        readStatus: 'NOT_OPENED',
+        sendStatus: 'NOT_SENT',
+        signingStatus: 'NOT_SIGNED',
+      },
+    });
+
+    // 5. Add fields to the template
+    // Add TEXT field
+    const textField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.TEXT,
+        page: 1,
+        positionX: 5,
+        positionY: 5,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'text',
+          label: 'Default Text Field',
+        },
+      },
+    });
+
+    // Add NUMBER field
+    const numberField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.NUMBER,
+        page: 1,
+        positionX: 5,
+        positionY: 15,
+        width: 10,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'number',
+          label: 'Default Number Field',
+        },
+      },
+    });
+
+    // 6. Sign in as the user
+    await apiSignin({
+      page,
+      email: user.email,
+    });
+
+    // 7. Navigate to the template
+    await page.goto(`${WEBAPP_BASE_URL}/templates/${template.id}`);
+
+    // 8. Create a document from the template without prefilled fields
+    const response = await request.post(
+      `${WEBAPP_BASE_URL}/api/v1/templates/${template.id}/generate-document`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        data: {
+          title: 'Document with Default Fields',
+          recipients: [
+            {
+              id: recipient.id,
+              email: 'recipient@example.com',
+              name: 'Test Recipient',
+              role: 'SIGNER',
+            },
+          ],
+        },
+      },
+    );
+
+    const responseData = await response.json();
+
+    expect(response.ok()).toBeTruthy();
+    expect(response.status()).toBe(200);
+
+    expect(responseData.documentId).toBeDefined();
+
+    // 9. Verify the document was created with default fields
+    const document = await prisma.document.findUnique({
+      where: {
+        id: responseData.documentId,
+      },
+      include: {
+        fields: true,
+      },
+    });
+
+    expect(document).not.toBeNull();
+
+    // 10. Verify fields have their default values
+    const documentTextField = document?.fields.find((field) => field.type === FieldType.TEXT);
+    expect(documentTextField?.fieldMeta).toMatchObject({
+      type: 'text',
+      label: 'Default Text Field',
+    });
+
+    const documentNumberField = document?.fields.find((field) => field.type === FieldType.NUMBER);
+    expect(documentNumberField?.fieldMeta).toMatchObject({
+      type: 'number',
+      label: 'Default Number Field',
+    });
+
+    // 11. Sign in as the recipient and verify the default fields are visible
+    const documentRecipient = await prisma.recipient.findFirst({
+      where: {
+        documentId: document?.id,
+        email: 'recipient@example.com',
+      },
+    });
+
+    expect(documentRecipient).not.toBeNull();
+
+    const sendResponse = await request.post(
+      `${WEBAPP_BASE_URL}/api/v1/documents/${document?.id}/send`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        data: {
+          sendEmail: false,
+        },
+      },
+    );
+
+    expect(sendResponse.ok()).toBeTruthy();
+    expect(sendResponse.status()).toBe(200);
+
+    // Visit the signing page
+    await page.goto(`${WEBAPP_BASE_URL}/sign/${documentRecipient?.token}`);
+
+    // Verify the default fields are visible with correct labels
+    await expect(page.getByText('Default Text Field')).toBeVisible();
+    await expect(page.getByText('Default Number Field')).toBeVisible();
+  });
+
+  test('should handle invalid field prefill values', async ({ request }) => {
+    // 1. Create a user
+    const user = await seedUser();
+
+    // 2. Create an API token for the user
+    const { token } = await createApiToken({
+      userId: user.id,
+      tokenName: 'test-token',
+      expiresIn: null,
+    });
+
+    // 3. Create a template using seedBlankTemplate
+    const template = await seedBlankTemplate(user, {
+      createTemplateOptions: {
+        title: 'Template for Invalid Test',
+        visibility: 'EVERYONE',
+      },
+    });
+
+    // 4. Create a recipient for the template
+    const recipient = await prisma.recipient.create({
+      data: {
+        templateId: template.id,
+        email: 'recipient@example.com',
+        name: 'Test Recipient',
+        role: RecipientRole.SIGNER,
+        token: 'test-token',
+        readStatus: 'NOT_OPENED',
+        sendStatus: 'NOT_SENT',
+        signingStatus: 'NOT_SIGNED',
+      },
+    });
+
+    // 5. Add a field to the template
+    const field = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.RADIO,
+        page: 1,
+        positionX: 100,
+        positionY: 100,
+        width: 100,
+        height: 50,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'radio',
+          label: 'Radio Field',
+          values: [
+            { id: 1, value: 'Option A', checked: false },
+            { id: 2, value: 'Option B', checked: false },
+          ],
+        },
+      },
+    });
+
+    // 6. Try to create a document with invalid prefill value
+    const response = await request.post(
+      `${WEBAPP_BASE_URL}/api/v1/templates/${template.id}/generate-document`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        data: {
+          title: 'Document with Invalid Prefill',
+          recipients: [
+            {
+              id: recipient.id,
+              email: 'recipient@example.com',
+              name: 'Test Recipient',
+              role: 'SIGNER',
+            },
+          ],
+          prefillFields: [
+            {
+              id: field.id,
+              type: 'radio',
+              label: 'Invalid Radio',
+              value: 'Non-existent Option', // This option doesn't exist
+            },
+          ],
+        },
+      },
+    );
+
+    // 7. Verify the request fails with appropriate error
+    expect(response.ok()).toBeFalsy();
+    expect(response.status()).toBe(400);
+
+    const errorData = await response.json();
+    expect(errorData.message).toContain('not found in options for RADIO field');
+  });
+});

packages/app-tests/e2e/api/v2/template-field-prefill.spec.ts

@@ -0,0 +1,602 @@
+import { expect, test } from '@playwright/test';
+
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+import { createApiToken } from '@documenso/lib/server-only/public-api/create-api-token';
+import type { TCheckboxFieldMeta, TRadioFieldMeta } from '@documenso/lib/types/field-meta';
+import { prisma } from '@documenso/prisma';
+import { FieldType, RecipientRole } from '@documenso/prisma/client';
+import { seedBlankTemplate } from '@documenso/prisma/seed/templates';
+import { seedUser } from '@documenso/prisma/seed/users';
+
+import { apiSignin } from '../../fixtures/authentication';
+
+const WEBAPP_BASE_URL = NEXT_PUBLIC_WEBAPP_URL();
+
+test.describe('Template Field Prefill API v2', () => {
+  test('should create a document from template with prefilled fields', async ({
+    page,
+    request,
+  }) => {
+    // 1. Create a user
+    const user = await seedUser();
+
+    // 2. Create an API token for the user
+    const { token } = await createApiToken({
+      userId: user.id,
+      tokenName: 'test-token',
+      expiresIn: null,
+    });
+
+    // 3. Create a template with seedBlankTemplate
+    const template = await seedBlankTemplate(user, {
+      createTemplateOptions: {
+        title: 'Template with Advanced Fields V2',
+      },
+    });
+
+    // 4. Create a recipient for the template
+    const recipient = await prisma.recipient.create({
+      data: {
+        templateId: template.id,
+        email: 'recipient@example.com',
+        name: 'Test Recipient',
+        role: RecipientRole.SIGNER,
+        token: 'test-token',
+        readStatus: 'NOT_OPENED',
+        sendStatus: 'NOT_SENT',
+        signingStatus: 'NOT_SIGNED',
+      },
+    });
+
+    // 5. Add fields to the template
+    // Add TEXT field
+    const textField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.TEXT,
+        page: 1,
+        positionX: 5,
+        positionY: 5,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'text',
+          label: 'Text Field',
+        },
+      },
+    });
+
+    // Add NUMBER field
+    const numberField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.NUMBER,
+        page: 1,
+        positionX: 5,
+        positionY: 15,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'number',
+          label: 'Number Field',
+        },
+      },
+    });
+
+    // Add RADIO field
+    const radioField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.RADIO,
+        page: 1,
+        positionX: 5,
+        positionY: 25,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'radio',
+          label: 'Radio Field',
+          values: [
+            { id: 1, value: 'Option A', checked: false },
+            { id: 2, value: 'Option B', checked: false },
+          ],
+        },
+      },
+    });
+
+    // Add CHECKBOX field
+    const checkboxField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.CHECKBOX,
+        page: 1,
+        positionX: 5,
+        positionY: 35,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'checkbox',
+          label: 'Checkbox Field',
+          values: [
+            { id: 1, value: 'Check A', checked: false },
+            { id: 2, value: 'Check B', checked: false },
+          ],
+        },
+      },
+    });
+
+    // Add DROPDOWN field
+    const dropdownField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.DROPDOWN,
+        page: 1,
+        positionX: 5,
+        positionY: 45,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'dropdown',
+          label: 'Dropdown Field',
+          values: [{ value: 'Select A' }, { value: 'Select B' }],
+        },
+      },
+    });
+
+    // 6. Sign in as the user
+    await apiSignin({
+      page,
+      email: user.email,
+    });
+
+    // 7. Navigate to the template
+    await page.goto(`${WEBAPP_BASE_URL}/templates/${template.id}`);
+
+    // 8. Create a document from the template with prefilled fields using v2 API
+    const response = await request.post(`${WEBAPP_BASE_URL}/api/v2-beta/template/use`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        templateId: template.id,
+        recipients: [
+          {
+            id: recipient.id,
+            email: 'recipient@example.com',
+            name: 'Test Recipient',
+          },
+        ],
+        prefillFields: [
+          {
+            id: textField.id,
+            type: 'text',
+            label: 'Prefilled Text',
+            value: 'This is prefilled text',
+          },
+          {
+            id: numberField.id,
+            type: 'number',
+            label: 'Prefilled Number',
+            value: '42',
+          },
+          {
+            id: radioField.id,
+            type: 'radio',
+            label: 'Prefilled Radio',
+            value: 'Option A',
+          },
+          {
+            id: checkboxField.id,
+            type: 'checkbox',
+            label: 'Prefilled Checkbox',
+            value: ['Check A', 'Check B'],
+          },
+          {
+            id: dropdownField.id,
+            type: 'dropdown',
+            label: 'Prefilled Dropdown',
+            value: 'Select B',
+          },
+        ],
+      },
+    });
+
+    const responseData = await response.json();
+
+    expect(response.ok()).toBeTruthy();
+    expect(response.status()).toBe(200);
+
+    expect(responseData.id).toBeDefined();
+
+    // 9. Verify the document was created with prefilled fields
+    const document = await prisma.document.findUnique({
+      where: {
+        id: responseData.id,
+      },
+      include: {
+        fields: true,
+      },
+    });
+
+    expect(document).not.toBeNull();
+
+    // 10. Verify each field has the correct prefilled values
+    const documentTextField = document?.fields.find(
+      (field) => field.type === FieldType.TEXT && field.fieldMeta?.type === 'text',
+    );
+    expect(documentTextField?.fieldMeta).toMatchObject({
+      type: 'text',
+      label: 'Prefilled Text',
+      text: 'This is prefilled text',
+    });
+
+    const documentNumberField = document?.fields.find(
+      (field) => field.type === FieldType.NUMBER && field.fieldMeta?.type === 'number',
+    );
+    expect(documentNumberField?.fieldMeta).toMatchObject({
+      type: 'number',
+      label: 'Prefilled Number',
+      value: '42',
+    });
+
+    const documentRadioField = document?.fields.find(
+      (field) => field.type === FieldType.RADIO && field.fieldMeta?.type === 'radio',
+    );
+    expect(documentRadioField?.fieldMeta).toMatchObject({
+      type: 'radio',
+      label: 'Prefilled Radio',
+    });
+    // Check that the correct radio option is selected
+    const radioValues = (documentRadioField?.fieldMeta as TRadioFieldMeta)?.values || [];
+    const selectedRadioOption = radioValues.find((option) => option.checked);
+    expect(selectedRadioOption?.value).toBe('Option A');
+
+    const documentCheckboxField = document?.fields.find(
+      (field) => field.type === FieldType.CHECKBOX && field.fieldMeta?.type === 'checkbox',
+    );
+    expect(documentCheckboxField?.fieldMeta).toMatchObject({
+      type: 'checkbox',
+      label: 'Prefilled Checkbox',
+    });
+    // Check that the correct checkbox options are selected
+    const checkboxValues = (documentCheckboxField?.fieldMeta as TCheckboxFieldMeta)?.values || [];
+    const checkedOptions = checkboxValues.filter((option) => option.checked);
+    expect(checkedOptions.length).toBe(2);
+    expect(checkedOptions.map((option) => option.value)).toContain('Check A');
+    expect(checkedOptions.map((option) => option.value)).toContain('Check B');
+
+    const documentDropdownField = document?.fields.find(
+      (field) => field.type === FieldType.DROPDOWN && field.fieldMeta?.type === 'dropdown',
+    );
+    expect(documentDropdownField?.fieldMeta).toMatchObject({
+      type: 'dropdown',
+      label: 'Prefilled Dropdown',
+      defaultValue: 'Select B',
+    });
+
+    const sendResponse = await request.post(`${WEBAPP_BASE_URL}/api/v2-beta/document/distribute`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        documentId: document?.id,
+        meta: {
+          subject: 'Test Subject',
+          message: 'Test Message',
+        },
+      },
+    });
+
+    await expect(sendResponse.ok()).toBeTruthy();
+    await expect(sendResponse.status()).toBe(200);
+
+    // 11. Sign in as the recipient and verify the prefilled fields are visible
+    const documentRecipient = await prisma.recipient.findFirst({
+      where: {
+        documentId: document?.id,
+        email: 'recipient@example.com',
+      },
+    });
+
+    expect(documentRecipient).not.toBeNull();
+
+    // Visit the signing page
+    await page.goto(`${WEBAPP_BASE_URL}/sign/${documentRecipient?.token}`);
+
+    // Verify the prefilled fields are visible with correct values
+    // Text field
+    await expect(page.getByText('This is prefilled')).toBeVisible();
+
+    // Number field
+    await expect(page.getByText('42')).toBeVisible();
+
+    // Radio field
+    await expect(page.getByText('Option A')).toBeVisible();
+    await expect(page.getByRole('radio', { name: 'Option A' })).toBeChecked();
+
+    // Checkbox field
+    await expect(page.getByText('Check A')).toBeVisible();
+    await expect(page.getByText('Check B')).toBeVisible();
+    await expect(page.getByRole('checkbox', { name: 'Check A' })).toBeChecked();
+    await expect(page.getByRole('checkbox', { name: 'Check B' })).toBeChecked();
+
+    // Dropdown field
+    await expect(page.getByText('Select B')).toBeVisible();
+  });
+
+  test('should create a document from template without prefilled fields', async ({
+    page,
+    request,
+  }) => {
+    // 1. Create a user
+    const user = await seedUser();
+
+    // 2. Create an API token for the user
+    const { token } = await createApiToken({
+      userId: user.id,
+      tokenName: 'test-token',
+      expiresIn: null,
+    });
+
+    // 3. Create a template with seedBlankTemplate
+    const template = await seedBlankTemplate(user, {
+      createTemplateOptions: {
+        title: 'Template with Default Fields V2',
+      },
+    });
+
+    // 4. Create a recipient for the template
+    const recipient = await prisma.recipient.create({
+      data: {
+        templateId: template.id,
+        email: 'recipient@example.com',
+        name: 'Test Recipient',
+        role: RecipientRole.SIGNER,
+        token: 'test-token',
+        readStatus: 'NOT_OPENED',
+        sendStatus: 'NOT_SENT',
+        signingStatus: 'NOT_SIGNED',
+      },
+    });
+
+    // 5. Add fields to the template
+    // Add TEXT field
+    const textField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.TEXT,
+        page: 1,
+        positionX: 5,
+        positionY: 5,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'text',
+          label: 'Default Text Field',
+        },
+      },
+    });
+
+    // Add NUMBER field
+    const numberField = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.NUMBER,
+        page: 1,
+        positionX: 5,
+        positionY: 15,
+        width: 20,
+        height: 5,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'number',
+          label: 'Default Number Field',
+        },
+      },
+    });
+
+    // 6. Sign in as the user
+    await apiSignin({
+      page,
+      email: user.email,
+    });
+
+    // 7. Navigate to the template
+    await page.goto(`${WEBAPP_BASE_URL}/templates/${template.id}`);
+
+    // 8. Create a document from the template without prefilled fields using v2 API
+    const response = await request.post(`${WEBAPP_BASE_URL}/api/v2-beta/template/use`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        templateId: template.id,
+        recipients: [
+          {
+            id: recipient.id,
+            email: 'recipient@example.com',
+            name: 'Test Recipient',
+          },
+        ],
+      },
+    });
+
+    const responseData = await response.json();
+
+    expect(response.ok()).toBeTruthy();
+    expect(response.status()).toBe(200);
+
+    expect(responseData.id).toBeDefined();
+
+    // 9. Verify the document was created with default fields
+    const document = await prisma.document.findUnique({
+      where: {
+        id: responseData.id,
+      },
+      include: {
+        fields: true,
+      },
+    });
+
+    expect(document).not.toBeNull();
+
+    // 10. Verify fields have their default values
+    const documentTextField = document?.fields.find((field) => field.type === FieldType.TEXT);
+    expect(documentTextField?.fieldMeta).toMatchObject({
+      type: 'text',
+      label: 'Default Text Field',
+    });
+
+    const documentNumberField = document?.fields.find((field) => field.type === FieldType.NUMBER);
+    expect(documentNumberField?.fieldMeta).toMatchObject({
+      type: 'number',
+      label: 'Default Number Field',
+    });
+
+    const sendResponse = await request.post(`${WEBAPP_BASE_URL}/api/v2-beta/document/distribute`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        documentId: document?.id,
+        meta: {
+          subject: 'Test Subject',
+          message: 'Test Message',
+        },
+      },
+    });
+
+    await expect(sendResponse.ok()).toBeTruthy();
+    await expect(sendResponse.status()).toBe(200);
+
+    // 11. Sign in as the recipient and verify the default fields are visible
+    const documentRecipient = await prisma.recipient.findFirst({
+      where: {
+        documentId: document?.id,
+        email: 'recipient@example.com',
+      },
+    });
+
+    expect(documentRecipient).not.toBeNull();
+
+    // Visit the signing page
+    await page.goto(`${WEBAPP_BASE_URL}/sign/${documentRecipient?.token}`);
+
+    await expect(page.getByText('This is prefilled')).not.toBeVisible();
+  });
+
+  test('should handle invalid field prefill values', async ({ request }) => {
+    // 1. Create a user
+    const user = await seedUser();
+
+    // 2. Create an API token for the user
+    const { token } = await createApiToken({
+      userId: user.id,
+      tokenName: 'test-token',
+      expiresIn: null,
+    });
+
+    // 3. Create a template using seedBlankTemplate
+    const template = await seedBlankTemplate(user, {
+      createTemplateOptions: {
+        title: 'Template for Invalid Test V2',
+        visibility: 'EVERYONE',
+      },
+    });
+
+    // 4. Create a recipient for the template
+    const recipient = await prisma.recipient.create({
+      data: {
+        templateId: template.id,
+        email: 'recipient@example.com',
+        name: 'Test Recipient',
+        role: RecipientRole.SIGNER,
+        token: 'test-token',
+        readStatus: 'NOT_OPENED',
+        sendStatus: 'NOT_SENT',
+        signingStatus: 'NOT_SIGNED',
+      },
+    });
+
+    // 5. Add a field to the template
+    const field = await prisma.field.create({
+      data: {
+        templateId: template.id,
+        recipientId: recipient.id,
+        type: FieldType.RADIO,
+        page: 1,
+        positionX: 100,
+        positionY: 100,
+        width: 100,
+        height: 50,
+        customText: '',
+        inserted: false,
+        fieldMeta: {
+          type: 'radio',
+          label: 'Radio Field',
+          values: [
+            { id: 1, value: 'Option A', checked: false },
+            { id: 2, value: 'Option B', checked: false },
+          ],
+        },
+      },
+    });
+
+    // 7. Try to create a document with invalid prefill value
+    const response = await request.post(`${WEBAPP_BASE_URL}/api/v2-beta/template/use`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        templateId: template.id,
+        recipients: [
+          {
+            id: recipient.id,
+            email: 'recipient@example.com',
+            name: 'Test Recipient',
+          },
+        ],
+        prefillFields: [
+          {
+            id: field.id,
+            type: 'radio',
+            label: 'Invalid Radio',
+            value: 'Non-existent Option', // This option doesn't exist
+          },
+        ],
+      },
+    });
+
+    // 8. Verify the request fails with appropriate error
+    expect(response.ok()).toBeFalsy();
+    expect(response.status()).toBe(400);
+
+    const errorData = await response.json();
+    expect(errorData.message).toContain('not found in options for RADIO field');
+  });
+});

packages/app-tests/e2e/document-auth/action-auth.spec.ts

@@ -1,11 +1,11 @@
 import { expect, test } from '@playwright/test';
+import { FieldType } from '@prisma/client';
 
 import { ZRecipientAuthOptionsSchema } from '@documenso/lib/types/document-auth';
 import {
   createDocumentAuthOptions,
   createRecipientAuthOptions,
 } from '@documenso/lib/utils/document-auth';
-import { FieldType } from '@documenso/prisma/client';
 import {
   seedPendingDocumentNoFields,
   seedPendingDocumentWithFullFields,
@@ -246,7 +246,9 @@ test('[DOCUMENT_AUTH]: should allow field signing when required for recipient au
       });
     }
 
-    await signSignaturePad(page);
+    if (fields.some((field) => field.type === FieldType.SIGNATURE)) {
+      await signSignaturePad(page);
+    }
 
     for (const field of fields) {
       await page.locator(`#field-${field.id}`).getByRole('button').click();
@@ -349,7 +351,9 @@ test('[DOCUMENT_AUTH]: should allow field signing when required for recipient an
       });
     }
 
-    await signSignaturePad(page);
+    if (fields.some((field) => field.type === FieldType.SIGNATURE)) {
+      await signSignaturePad(page);
+    }
 
     for (const field of fields) {
       await page.locator(`#field-${field.id}`).getByRole('button').click();

packages/app-tests/e2e/document-flow/stepper-component.spec.ts

@@ -1,16 +1,16 @@
 import { expect, test } from '@playwright/test';
-import { DateTime } from 'luxon';
-import path from 'node:path';
-
-import { getRecipientByEmail } from '@documenso/lib/server-only/recipient/get-recipient-by-email';
-import { prisma } from '@documenso/prisma';
 import {
   DocumentSigningOrder,
   DocumentStatus,
   FieldType,
   RecipientRole,
   SigningStatus,
-} from '@documenso/prisma/client';
+} from '@prisma/client';
+import { DateTime } from 'luxon';
+import path from 'node:path';
+
+import { getRecipientByEmail } from '@documenso/lib/server-only/recipient/get-recipient-by-email';
+import { prisma } from '@documenso/prisma';
 import {
   seedBlankDocument,
   seedPendingDocumentWithFullFields,
@@ -377,7 +377,9 @@ test('[DOCUMENT_FLOW]: should be able to approve a document', async ({ page }) =
       await expect(page.locator(`#field-${field.id}`)).toHaveAttribute('data-inserted', 'true');
     }
 
-    await page.getByRole('button', { name: 'Complete' }).click();
+    await page
+      .getByRole('button', { name: role === RecipientRole.SIGNER ? 'Complete' : 'Approve' })
+      .click();
     await page
       .getByRole('button', { name: role === RecipientRole.SIGNER ? 'Sign' : 'Approve' })
       .click();
@@ -447,7 +449,7 @@ test('[DOCUMENT_FLOW]: should be able to create, send with redirect url, sign a
   const { status } = await getDocumentByToken(token);
   expect(status).toBe(DocumentStatus.PENDING);
 
-  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Approve' }).click();
   await expect(page.getByRole('dialog').getByText('Complete Approval').first()).toBeVisible();
   await page.getByRole('button', { name: 'Approve' }).click();
 

packages/app-tests/e2e/features/include-document-certificate.spec.ts

@@ -1,10 +1,10 @@
 import { expect, test } from '@playwright/test';
+import { DocumentStatus, FieldType } from '@prisma/client';
 import { PDFDocument } from 'pdf-lib';
 
 import { getDocumentByToken } from '@documenso/lib/server-only/document/get-document-by-token';
 import { getFile } from '@documenso/lib/universal/upload/get-file';
 import { prisma } from '@documenso/prisma';
-import { DocumentStatus, FieldType } from '@documenso/prisma/client';
 import { seedPendingDocumentWithFullFields } from '@documenso/prisma/seed/documents';
 import { seedTeam } from '@documenso/prisma/seed/teams';
 import { seedUser } from '@documenso/prisma/seed/users';
@@ -222,7 +222,10 @@ test.describe('Signing Certificate Tests', () => {
 
     // Toggle signing certificate setting
     await page.getByLabel('Include the Signing Certificate in the Document').click();
-    await page.getByRole('button', { name: /Save/ }).first().click();
+    await page
+      .getByRole('button', { name: /Update/ })
+      .first()
+      .click();
 
     await page.waitForTimeout(1000);
 
@@ -236,7 +239,10 @@ test.describe('Signing Certificate Tests', () => {
 
     // Toggle the setting back to true
     await page.getByLabel('Include the Signing Certificate in the Document').click();
-    await page.getByRole('button', { name: /Save/ }).first().click();
+    await page
+      .getByRole('button', { name: /Update/ })
+      .first()
+      .click();
 
     await page.waitForTimeout(1000);
 

packages/app-tests/e2e/fixtures/signature.ts

@@ -3,38 +3,12 @@ import type { Page } from '@playwright/test';
 export const signSignaturePad = async (page: Page) => {
   await page.waitForTimeout(200);
 
-  const canvas = page.getByTestId('signature-pad');
+  await page.getByTestId('signature-pad-dialog-button').click();
 
-  const box = await canvas.boundingBox();
+  // Click type tab
+  await page.getByRole('tab', { name: 'Type' }).click();
+  await page.getByTestId('signature-pad-type-input').fill('Signature');
 
-  if (!box) {
-    throw new Error('Signature pad not found');
-  }
-
-  // Calculate center point
-  const centerX = box.x + box.width / 2;
-  const centerY = box.y + box.height / 2;
-
-  // Calculate square size (making it slightly smaller than the canvas)
-  const squareSize = Math.min(box.width, box.height) * 0.4; // 40% of the smallest dimension
-
-  // Move to center
-  await page.mouse.move(centerX, centerY);
-  await page.mouse.down();
-
-  // Draw square clockwise from center
-  // Move right
-  await page.mouse.move(centerX + squareSize, centerY, { steps: 10 });
-  // Move down
-  await page.mouse.move(centerX + squareSize, centerY + squareSize, { steps: 10 });
-  // Move left
-  await page.mouse.move(centerX - squareSize, centerY + squareSize, { steps: 10 });
-  // Move up
-  await page.mouse.move(centerX - squareSize, centerY - squareSize, { steps: 10 });
-  // Move right
-  await page.mouse.move(centerX + squareSize, centerY - squareSize, { steps: 10 });
-  // Move down to close the square
-  await page.mouse.move(centerX + squareSize, centerY, { steps: 10 });
-
-  await page.mouse.up();
+  // Click Next button
+  await page.getByRole('button', { name: 'Next' }).click();
 };

packages/app-tests/e2e/public-profiles/public-profiles.spec.ts

@@ -0,0 +1,144 @@
+import { expect, test } from '@playwright/test';
+
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+import { seedTeam } from '@documenso/prisma/seed/teams';
+import { seedDirectTemplate } from '@documenso/prisma/seed/templates';
+import { seedUser } from '@documenso/prisma/seed/users';
+
+import { apiSignin } from '../fixtures/authentication';
+
+test.describe.configure({ mode: 'parallel' });
+
+test('[PUBLIC_PROFILE]: create profile', async ({ page }) => {
+  const user = await seedUser();
+
+  // Create direct template.
+  const directTemplate = await seedDirectTemplate({
+    userId: user.id,
+  });
+
+  await apiSignin({
+    page,
+    email: user.email,
+    redirectPath: '/settings/public-profile',
+  });
+
+  const publicProfileUrl = Date.now().toString();
+  const publicProfileBio = `public-profile-bio`;
+
+  await page.getByRole('textbox', { name: 'Public profile URL' }).click();
+  await page.getByRole('textbox', { name: 'Public profile URL' }).fill(publicProfileUrl);
+
+  await page.getByRole('textbox', { name: 'Bio' }).click();
+  await page.getByRole('textbox', { name: 'Bio' }).fill(publicProfileBio);
+
+  await page.getByRole('button', { name: 'Update' }).click();
+
+  await expect(page.getByRole('status').first()).toContainText(
+    'Your public profile has been updated.',
+  );
+
+  // Link direct template to public profile.
+  await page.getByRole('button', { name: 'Link template' }).click();
+  await page.getByRole('cell', { name: directTemplate.title }).click();
+  await page.getByRole('button', { name: 'Continue' }).click();
+
+  await page.getByRole('textbox', { name: 'Title *' }).fill('public-direct-template-title');
+  await page
+    .getByRole('textbox', { name: 'Description *' })
+    .fill('public-direct-template-description');
+  await page.getByRole('button', { name: 'Update' }).click();
+
+  // Check that public profile is disabled.
+  await page.goto(`${NEXT_PUBLIC_WEBAPP_URL()}/p/${publicProfileUrl}`);
+  await expect(page.locator('body')).toContainText('404 Profile not found');
+
+  // Go back to public profile page.
+  await page.goto(`${NEXT_PUBLIC_WEBAPP_URL()}/settings/public-profile`);
+  await page.getByRole('switch').click();
+
+  // Assert values.
+  await page.goto(`${NEXT_PUBLIC_WEBAPP_URL()}/p/${publicProfileUrl}`);
+  await expect(page.getByRole('main')).toContainText(publicProfileBio);
+  await expect(page.locator('body')).toContainText('public-direct-template-title');
+  await expect(page.locator('body')).toContainText('public-direct-template-description');
+
+  await page.getByRole('link', { name: 'Sign' }).click();
+  await page.getByRole('button', { name: 'Continue' }).click();
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Sign' }).click();
+
+  await expect(page.getByRole('heading', { name: 'Document Signed' })).toBeVisible();
+  await expect(page.getByRole('heading')).toContainText('Document Signed');
+});
+
+test('[PUBLIC_PROFILE]: create team profile', async ({ page }) => {
+  const team = await seedTeam({
+    createTeamMembers: 1,
+  });
+
+  const user = team.owner;
+
+  // Create direct template.
+  const directTemplate = await seedDirectTemplate({
+    userId: user.id,
+    teamId: team.id,
+  });
+
+  // Create non team template to make sure you can only see the team one.
+  // Will be indirectly asserted because test should fail when 2 elements appear.
+  await seedDirectTemplate({
+    userId: user.id,
+  });
+
+  await apiSignin({
+    page,
+    email: user.email,
+    redirectPath: `/t/${team.url}/settings/public-profile`,
+  });
+
+  const publicProfileUrl = team.url;
+  const publicProfileBio = `public-profile-bio`;
+
+  await page.getByRole('textbox', { name: 'Bio' }).click();
+  await page.getByRole('textbox', { name: 'Bio' }).fill(publicProfileBio);
+
+  await page.getByRole('button', { name: 'Update' }).click();
+
+  await expect(page.getByRole('status').first()).toContainText(
+    'Your public profile has been updated.',
+  );
+
+  // Link direct template to public profile.
+  await page.getByRole('button', { name: 'Link template' }).click();
+  await page.getByRole('cell', { name: directTemplate.title }).click();
+  await page.getByRole('button', { name: 'Continue' }).click();
+
+  await page.getByRole('textbox', { name: 'Title *' }).fill('public-direct-template-title');
+  await page
+    .getByRole('textbox', { name: 'Description *' })
+    .fill('public-direct-template-description');
+  await page.getByRole('button', { name: 'Update' }).click();
+
+  // Check that public profile is disabled.
+  await page.goto(`${NEXT_PUBLIC_WEBAPP_URL()}/p/${publicProfileUrl}`);
+  await expect(page.locator('body')).toContainText('404 Profile not found');
+
+  // Go back to public profile page.
+  await page.goto(`${NEXT_PUBLIC_WEBAPP_URL()}/t/${team.url}/settings/public-profile`);
+  await page.getByRole('switch').click();
+
+  // Assert values.
+  await page.goto(`${NEXT_PUBLIC_WEBAPP_URL()}/p/${publicProfileUrl}`);
+  await expect(page.getByRole('main')).toContainText(publicProfileBio);
+  await expect(page.locator('body')).toContainText('public-direct-template-title');
+  await expect(page.locator('body')).toContainText('public-direct-template-description');
+
+  await page.getByRole('link', { name: 'Sign' }).click();
+  await page.getByRole('button', { name: 'Continue' }).click();
+  await page.getByRole('button', { name: 'Complete' }).click();
+  await page.getByRole('button', { name: 'Sign' }).click();
+
+  await expect(page.getByRole('heading', { name: 'Document Signed' })).toBeVisible();
+  await expect(page.getByRole('heading')).toContainText('Document Signed');
+});

packages/app-tests/e2e/teams/search-documents.spec.ts

@@ -1,6 +1,6 @@
 import { expect, test } from '@playwright/test';
+import { DocumentStatus, TeamMemberRole } from '@prisma/client';
 
-import { DocumentStatus, TeamMemberRole } from '@documenso/prisma/client';
 import { seedDocuments, seedTeamDocuments } from '@documenso/prisma/seed/documents';
 import { seedTeam, seedTeamMember } from '@documenso/prisma/seed/teams';
 import { seedUser } from '@documenso/prisma/seed/users';

packages/app-tests/e2e/teams/team-documents.spec.ts

@@ -1,6 +1,6 @@
 import { expect, test } from '@playwright/test';
+import { DocumentStatus, DocumentVisibility, TeamMemberRole } from '@prisma/client';
 
-import { DocumentStatus, DocumentVisibility, TeamMemberRole } from '@documenso/prisma/client';
 import { seedBlankDocument } from '@documenso/prisma/seed/documents';
 import { seedDocuments, seedTeamDocuments } from '@documenso/prisma/seed/documents';
 import { seedTeam, seedTeamEmail, seedTeamMember } from '@documenso/prisma/seed/teams';

packages/app-tests/e2e/teams/team-global-settings.spec.ts

@@ -23,7 +23,7 @@ test('[TEAMS]: update the default document visibility in the team global setting
   // !: Brittle selector
   await page.getByRole('combobox').first().click();
   await page.getByRole('option', { name: 'Admin' }).click();
-  await page.getByRole('button', { name: 'Save' }).first().click();
+  await page.getByRole('button', { name: 'Update' }).first().click();
 
   const toast = page.locator('li[role="status"][data-state="open"]').first();
   await expect(toast).toBeVisible();
@@ -47,7 +47,7 @@ test('[TEAMS]: update the sender details in the team global settings', async ({
 
   await expect(checkbox).toBeChecked();
 
-  await page.getByRole('button', { name: 'Save' }).first().click();
+  await page.getByRole('button', { name: 'Update' }).first().click();
 
   const toast = page.locator('li[role="status"][data-state="open"]').first();
   await expect(toast).toBeVisible();

packages/app-tests/e2e/teams/team-signature-settings.spec.ts

@@ -0,0 +1,182 @@
+import { expect, test } from '@playwright/test';
+
+import { prisma } from '@documenso/prisma';
+import {
+  seedTeamDocumentWithMeta,
+  seedTeamDocuments,
+  seedTeamTemplateWithMeta,
+} from '@documenso/prisma/seed/documents';
+
+import { apiSignin } from '../fixtures/authentication';
+
+test.describe.configure({ mode: 'parallel' });
+
+test('[TEAMS]: check that default team signature settings are all enabled', async ({ page }) => {
+  const { team } = await seedTeamDocuments();
+
+  await apiSignin({
+    page,
+    email: team.owner.email,
+    password: 'password',
+    redirectPath: `/t/${team.url}/settings/preferences`,
+  });
+
+  // Verify that the default created team settings has all signatures enabled
+  await expect(page.getByRole('combobox').filter({ hasText: 'Type' })).toBeVisible();
+  await expect(page.getByRole('combobox').filter({ hasText: 'Upload' })).toBeVisible();
+  await expect(page.getByRole('combobox').filter({ hasText: 'Draw' })).toBeVisible();
+
+  const document = await seedTeamDocumentWithMeta(team);
+
+  // Create a document and check the settings
+  await page.goto(`/t/${team.url}/documents/${document.id}/edit`);
+
+  // Verify that the settings match
+  await page.getByRole('button', { name: 'Advanced Options' }).click();
+  await expect(page.getByRole('combobox').filter({ hasText: 'Type' })).toBeVisible();
+  await expect(page.getByRole('combobox').filter({ hasText: 'Upload' })).toBeVisible();
+  await expect(page.getByRole('combobox').filter({ hasText: 'Draw' })).toBeVisible();
+
+  // Go to document and check that the signatured tabs are correct.
+  await page.goto(`/sign/${document.recipients[0].token}`);
+  await page.getByTestId('signature-pad-dialog-button').click();
+
+  // Check the tab values
+  await expect(page.getByRole('tab', { name: 'Type' })).toBeVisible();
+  await expect(page.getByRole('tab', { name: 'Upload' })).toBeVisible();
+  await expect(page.getByRole('tab', { name: 'Draw' })).toBeVisible();
+});
+
+test('[TEAMS]: check signature modes can be disabled', async ({ page }) => {
+  const { team } = await seedTeamDocuments();
+
+  await apiSignin({
+    page,
+    email: team.owner.email,
+    password: 'password',
+    redirectPath: `/t/${team.url}/settings/preferences`,
+  });
+
+  const allTabs = ['Type', 'Upload', 'Draw'];
+  const tabTest = [['Type', 'Upload', 'Draw'], ['Type', 'Upload'], ['Type']];
+
+  for (const tabs of tabTest) {
+    await page.goto(`/t/${team.url}/settings/preferences`);
+
+    // Update combobox to have the correct tabs
+    await page.getByTestId('signature-types-combobox').click();
+
+    await expect(page.getByRole('option', { name: 'Type' })).toBeVisible();
+    await expect(page.getByRole('option', { name: 'Upload' })).toBeVisible();
+    await expect(page.getByRole('option', { name: 'Draw' })).toBeVisible();
+
+    // Clear all selected items.
+    for (const tab of allTabs) {
+      const item = page.getByRole('option', { name: tab });
+
+      const isSelected = (await item.innerHTML()).includes('opacity-100');
+
+      if (isSelected) {
+        await item.click();
+      }
+    }
+
+    // Selected wanted items.
+    for (const tab of tabs) {
+      const item = page.getByRole('option', { name: tab });
+      await item.click();
+    }
+
+    await page.getByRole('button', { name: 'Update' }).first().click();
+
+    const document = await seedTeamDocumentWithMeta(team);
+
+    // Go to document and check that the signatured tabs are correct.
+    await page.goto(`/sign/${document.recipients[0].token}`);
+    await page.getByTestId('signature-pad-dialog-button').click();
+
+    // Check the tab values
+    for (const tab of allTabs) {
+      if (tabs.includes(tab)) {
+        await expect(page.getByRole('tab', { name: tab })).toBeVisible();
+      } else {
+        await expect(page.getByRole('tab', { name: tab })).not.toBeVisible();
+      }
+    }
+  }
+});
+
+test('[TEAMS]: check signature modes work for templates', async ({ page }) => {
+  const { team } = await seedTeamDocuments();
+
+  await apiSignin({
+    page,
+    email: team.owner.email,
+    password: 'password',
+    redirectPath: `/t/${team.url}/settings/preferences`,
+  });
+
+  const allTabs = ['Type', 'Upload', 'Draw'];
+  const tabTest = [['Type', 'Upload', 'Draw'], ['Type', 'Upload'], ['Type']];
+
+  for (const tabs of tabTest) {
+    await page.goto(`/t/${team.url}/settings/preferences`);
+
+    // Update combobox to have the correct tabs
+    await page.getByTestId('signature-types-combobox').click();
+
+    await expect(page.getByRole('option', { name: 'Type' })).toBeVisible();
+    await expect(page.getByRole('option', { name: 'Upload' })).toBeVisible();
+    await expect(page.getByRole('option', { name: 'Draw' })).toBeVisible();
+
+    // Clear all selected items.
+    for (const tab of allTabs) {
+      const item = page.getByRole('option', { name: tab });
+
+      const isSelected = (await item.innerHTML()).includes('opacity-100');
+
+      if (isSelected) {
+        await item.click();
+      }
+    }
+
+    // Selected wanted items.
+    for (const tab of tabs) {
+      const item = page.getByRole('option', { name: tab });
+      await item.click();
+    }
+
+    await page.getByRole('button', { name: 'Update' }).first().click();
+
+    const template = await seedTeamTemplateWithMeta(team);
+
+    await page.goto(`/t/${team.url}/templates/${template.id}`);
+    await page.getByRole('button', { name: 'Use' }).click();
+
+    // Check the send document checkbox to true
+    await page.getByLabel('Send document').click();
+    await page.getByRole('button', { name: 'Create and send' }).click();
+    await page.waitForTimeout(1000);
+
+    const document = await prisma.document.findFirst({
+      where: {
+        templateId: template.id,
+      },
+      include: {
+        documentMeta: true,
+      },
+    });
+
+    // Test kinda flaky, debug here.
+    // console.log({
+    //   tabs,
+    //   typedSignatureEnabled: document?.documentMeta?.typedSignatureEnabled,
+    //   uploadSignatureEnabled: document?.documentMeta?.uploadSignatureEnabled,
+    //   drawSignatureEnabled: document?.documentMeta?.drawSignatureEnabled,
+    // });
+
+    expect(document?.documentMeta?.typedSignatureEnabled).toEqual(tabs.includes('Type'));
+    expect(document?.documentMeta?.uploadSignatureEnabled).toEqual(tabs.includes('Upload'));
+    expect(document?.documentMeta?.drawSignatureEnabled).toEqual(tabs.includes('Draw'));
+  }
+});

packages/app-tests/e2e/templates-flow/template-settings-step.spec.ts

@@ -1,7 +1,7 @@
 import { expect, test } from '@playwright/test';
+import { TeamMemberRole } from '@prisma/client';
 
 import { prisma } from '@documenso/prisma';
-import { TeamMemberRole } from '@documenso/prisma/client';
 import { seedUserSubscription } from '@documenso/prisma/seed/subscriptions';
 import { seedTeam } from '@documenso/prisma/seed/teams';
 import { seedBlankTemplate } from '@documenso/prisma/seed/templates';
@@ -12,7 +12,7 @@ import { apiSignin } from '../fixtures/authentication';
 test.describe.configure({ mode: 'parallel' });
 
 test.describe('[EE_ONLY]', () => {
-  const enterprisePriceId = process.env.NEXT_PUBLIC_STRIPE_ENTERPRISE_PLAN_MONTHLY_PRICE_ID || '';
+  const enterprisePriceId = '';
 
   test.beforeEach(() => {
     test.skip(

packages/app-tests/e2e/templates/create-document-from-template.spec.ts

@@ -1,11 +1,11 @@
 import { expect, test } from '@playwright/test';
+import { DocumentDataType, TeamMemberRole } from '@prisma/client';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
 
 import { extractDocumentAuthMethods } from '@documenso/lib/utils/document-auth';
 import { prisma } from '@documenso/prisma';
-import { DocumentDataType, TeamMemberRole } from '@documenso/prisma/client';
 import { seedUserSubscription } from '@documenso/prisma/seed/subscriptions';
 import { seedTeam } from '@documenso/prisma/seed/teams';
 import { seedBlankTemplate } from '@documenso/prisma/seed/templates';
@@ -15,7 +15,7 @@ import { apiSignin } from '../fixtures/authentication';
 
 test.describe.configure({ mode: 'parallel' });
 
-const enterprisePriceId = process.env.NEXT_PUBLIC_STRIPE_ENTERPRISE_PLAN_MONTHLY_PRICE_ID || '';
+const enterprisePriceId = '';
 
 // Create a temporary PDF file for testing
 function createTempPdfFile() {

packages/app-tests/e2e/templates/direct-templates.spec.ts

@@ -298,6 +298,7 @@ test('[DIRECT_TEMPLATES]: use direct template link with 2 recipients', async ({
     await page.goto(formatDirectTemplatePath(template.directLink?.token || ''));
     await expect(page.getByRole('heading', { name: 'General' })).toBeVisible();
 
+    await page.waitForTimeout(1000);
     await page.getByPlaceholder('recipient@documenso.com').fill(seedTestEmail());
 
     await page.getByRole('button', { name: 'Continue' }).click();

packages/app-tests/e2e/user/password.spec.ts

@@ -0,0 +1,94 @@
+import { type Page, expect, test } from '@playwright/test';
+
+import { prisma } from '@documenso/prisma';
+import { seedUser } from '@documenso/prisma/seed/users';
+
+import { apiSignin, apiSignout } from '../fixtures/authentication';
+
+test.use({ storageState: { cookies: [], origins: [] } });
+
+test('[USER] can reset password via forgot password', async ({ page }: { page: Page }) => {
+  const oldPassword = 'Test123!';
+  const newPassword = 'Test124!';
+
+  const user = await seedUser({
+    password: oldPassword,
+  });
+
+  await page.goto('http://localhost:3000/signin');
+  await page.getByRole('link', { name: 'Forgot your password?' }).click();
+  await page.getByRole('textbox', { name: 'Email' }).fill(user.email);
+  await page.getByRole('button', { name: 'Reset Password' }).click();
+  await expect(page.locator('body')).toContainText('Reset email sent');
+
+  const foundToken = await prisma.passwordResetToken.findFirstOrThrow({
+    where: {
+      userId: user.id,
+    },
+    include: {
+      user: true,
+    },
+  });
+
+  await page.goto(`http://localhost:3000/reset-password/${foundToken.token}`);
+
+  // Assert that password cannot be same as old password.
+  await page.getByRole('textbox', { name: 'Password', exact: true }).fill(oldPassword);
+  await page.getByRole('textbox', { name: 'Repeat Password' }).fill(oldPassword);
+  await page.getByRole('button', { name: 'Reset Password' }).click();
+  await expect(page.locator('body')).toContainText(
+    'Your new password cannot be the same as your old password.',
+  );
+
+  // Assert password reset.
+  await page.getByRole('textbox', { name: 'Password', exact: true }).fill(newPassword);
+  await page.getByRole('textbox', { name: 'Repeat Password' }).fill(newPassword);
+  await page.getByRole('button', { name: 'Reset Password' }).click();
+  await expect(page.locator('body')).toContainText('Your password has been updated successfully.');
+
+  // Assert sign in works.
+  await apiSignin({
+    page,
+    email: user.email,
+    password: newPassword,
+  });
+
+  await page.waitForURL('/documents');
+  await expect(page).toHaveURL('/documents');
+});
+
+test('[USER] can reset password via user settings', async ({ page }: { page: Page }) => {
+  const oldPassword = 'Test123!';
+  const newPassword = 'Test124!';
+
+  const user = await seedUser({
+    password: oldPassword,
+  });
+
+  await apiSignin({
+    page,
+    email: user.email,
+    password: oldPassword,
+    redirectPath: '/settings/security',
+  });
+
+  await page.getByRole('textbox', { name: 'Current password' }).fill(oldPassword);
+  await page.getByRole('textbox', { name: 'New password' }).fill(newPassword);
+  await page.getByRole('textbox', { name: 'Repeat password' }).fill(newPassword);
+  await page.getByRole('button', { name: 'Update password' }).click();
+  await expect(page.locator('body')).toContainText('Password updated');
+
+  await apiSignout({
+    page,
+  });
+
+  // Assert sign in works.
+  await apiSignin({
+    page,
+    email: user.email,
+    password: newPassword,
+  });
+
+  await page.waitForURL('/documents');
+  await expect(page).toHaveURL('/documents');
+});

packages/app-tests/e2e/user/update-name.spec.ts

@@ -4,6 +4,7 @@ import { getUserByEmail } from '@documenso/lib/server-only/user/get-user-by-emai
 import { seedUser } from '@documenso/prisma/seed/users';
 
 import { apiSignin } from '../fixtures/authentication';
+import { signSignaturePad } from '../fixtures/signature';
 
 test('[USER] update full name', async ({ page }) => {
   const user = await seedUser();
@@ -12,7 +13,7 @@ test('[USER] update full name', async ({ page }) => {
 
   await page.getByLabel('Full Name').fill('John Doe');
 
-  await page.getByPlaceholder('Type your signature').fill('John Doe');
+  await signSignaturePad(page);
 
   await page.getByRole('button', { name: 'Update profile' }).click();
 

packages/auth/server/config.ts

@@ -1,6 +1,11 @@
 import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
 import { env } from '@documenso/lib/utils/env';
 
+/**
+ * How long a session should live for in milliseconds.
+ */
+export const AUTH_SESSION_LIFETIME = 1000 * 60 * 60 * 24 * 30; // 30 days.
+
 export type OAuthClientOptions = {
   id: string;
   scope: string[];

packages/auth/server/lib/session/session-cookies.ts

@@ -9,6 +9,8 @@ import {
 import { appLog } from '@documenso/lib/utils/debugger';
 import { env } from '@documenso/lib/utils/env';
 
+import { AUTH_SESSION_LIFETIME } from '../../config';
+import { extractCookieFromHeaders } from '../utils/cookies';
 import { generateSessionToken } from './session';
 
 export const sessionCookieName = formatSecureCookieName('sessionId');
@@ -30,22 +32,14 @@ const getAuthSecret = () => {
 export const sessionCookieOptions = {
   httpOnly: true,
   path: '/',
-  sameSite: useSecureCookies ? 'none' : 'lax', // Todo: This feels wrong?
+  sameSite: useSecureCookies ? 'none' : 'lax',
   secure: useSecureCookies,
   domain: getCookieDomain(),
-  // Todo: Max age for specific auth cookies.
+  expires: new Date(Date.now() + AUTH_SESSION_LIFETIME),
 } as const;
 
 export const extractSessionCookieFromHeaders = (headers: Headers): string | null => {
-  const cookieHeader = headers.get('cookie') || '';
-  const cookiePairs = cookieHeader.split(';');
-  const sessionCookie = cookiePairs.find((pair) => pair.trim().startsWith(sessionCookieName));
-
-  if (!sessionCookie) {
-    return null;
-  }
-
-  return sessionCookie.split('=')[1].trim();
+  return extractCookieFromHeaders(sessionCookieName, headers);
 };
 
 /**

packages/auth/server/lib/session/session.ts

@@ -5,6 +5,8 @@ import { type Session, type User, UserSecurityAuditLogType } from '@prisma/clien
 import type { RequestMetadata } from '@documenso/lib/universal/extract-request-metadata';
 import { prisma } from '@documenso/prisma';
 
+import { AUTH_SESSION_LIFETIME } from '../../config';
+
 /**
  * The user object to pass around the app.
  *
@@ -21,6 +23,7 @@ export type SessionUser = Pick<
   | 'roles'
   | 'signature'
   | 'url'
+  | 'customerId'
 >;
 
 export type SessionValidationResult =
@@ -54,7 +57,7 @@ export const createSession = async (
     userId,
     updatedAt: new Date(),
     createdAt: new Date(),
-    expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 30),
+    expiresAt: new Date(Date.now() + AUTH_SESSION_LIFETIME),
     ipAddress: metadata.ipAddress ?? null,
     userAgent: metadata.userAgent ?? null,
   };
@@ -97,6 +100,7 @@ export const validateSessionToken = async (token: string): Promise<SessionValida
           roles: true,
           signature: true,
           url: true,
+          customerId: true,
         },
       },
     },

packages/auth/server/lib/utils/cookies.ts

@@ -0,0 +1,14 @@
+/**
+ * Todo: Use library for cookies instead.
+ */
+export const extractCookieFromHeaders = (cookieName: string, headers: Headers): string | null => {
+  const cookieHeader = headers.get('cookie') || '';
+  const cookiePairs = cookieHeader.split(';');
+  const cookie = cookiePairs.find((pair) => pair.trim().startsWith(cookieName));
+
+  if (!cookie) {
+    return null;
+  }
+
+  return cookie.split('=')[1].trim();
+};

packages/auth/server/lib/utils/get-session.ts

@@ -38,7 +38,7 @@ export const getOptionalSession = async (
 };
 
 /**
- * Todo: Rethink, this is pretty sketchy.
+ * Todo: (RR7) Rethink, this is pretty sketchy.
  */
 const mapRequestToContextForCookie = (c: Context | Request) => {
   if (c instanceof Request) {

packages/auth/server/lib/utils/handle-oauth-callback-url.ts

@@ -1,11 +1,12 @@
+import { UserSecurityAuditLogType } from '@prisma/client';
 import { OAuth2Client, decodeIdToken } from 'arctic';
 import type { Context } from 'hono';
 import { deleteCookie } from 'hono/cookie';
+import { nanoid } from 'nanoid';
 
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { onCreateUserHook } from '@documenso/lib/server-only/user/create-user';
 import { prisma } from '@documenso/prisma';
-import { UserSecurityAuditLogType } from '@documenso/prisma/client';
 
 import type { OAuthClientOptions } from '../../config';
 import { AuthenticationErrorCode } from '../errors/error-codes';
@@ -144,7 +145,8 @@ export const handleOAuthCallbackUrl = async (options: HandleOAuthCallbackUrlOpti
           },
           data: {
             emailVerified: new Date(),
-            password: null, // Todo: Check this
+            password: null,
+            // Todo: (RR7) Will need to update the "password" account after the migration.
           },
         });
       }
@@ -162,6 +164,7 @@ export const handleOAuthCallbackUrl = async (options: HandleOAuthCallbackUrlOpti
         email: email,
         name: name,
         emailVerified: new Date(),
+        url: nanoid(17),
       },
     });
 
@@ -182,7 +185,7 @@ export const handleOAuthCallbackUrl = async (options: HandleOAuthCallbackUrlOpti
   });
 
   await onCreateUserHook(createdUser).catch((err) => {
-    // Todo: Add logging.
+    // Todo: (RR7) Add logging.
     console.error(err);
   });
 

packages/auth/server/routes/email-password.ts

@@ -1,5 +1,6 @@
 import { sValidator } from '@hono/standard-validator';
 import { compare } from '@node-rs/bcrypt';
+import { UserSecurityAuditLogType } from '@prisma/client';
 import { Hono } from 'hono';
 import { DateTime } from 'luxon';
 import { z } from 'zod';
@@ -22,7 +23,6 @@ import { updatePassword } from '@documenso/lib/server-only/user/update-password'
 import { verifyEmail } from '@documenso/lib/server-only/user/verify-email';
 import { env } from '@documenso/lib/utils/env';
 import { prisma } from '@documenso/prisma';
-import { UserSecurityAuditLogType } from '@documenso/prisma/client';
 
 import { AuthenticationErrorCode } from '../lib/errors/error-codes';
 import { getCsrfCookie } from '../lib/session/session-cookies';
@@ -50,7 +50,7 @@ export const emailPasswordRoute = new Hono<HonoAuthContext>()
 
     const csrfCookieToken = await getCsrfCookie(c);
 
-    // Todo: Add logging here.
+    // Todo: (RR7) Add logging here.
     if (csrfToken !== csrfCookieToken || !csrfCookieToken) {
       throw new AppError(AuthenticationErrorCode.InvalidRequest, {
         message: 'Invalid CSRF token',

packages/ee/server-only/limits/server.ts

@@ -1,8 +1,8 @@
+import { DocumentSource, SubscriptionStatus } from '@prisma/client';
 import { DateTime } from 'luxon';
 
 import { IS_BILLING_ENABLED } from '@documenso/lib/constants/app';
 import { prisma } from '@documenso/prisma';
-import { DocumentSource, SubscriptionStatus } from '@documenso/prisma/client';
 
 import { getDocumentRelatedPrices } from '../stripe/get-document-related-prices.ts';
 import { FREE_PLAN_LIMITS, SELFHOSTED_PLAN_LIMITS, TEAM_PLAN_LIMITS } from './constants';

packages/ee/server-only/stripe/get-customer.ts

@@ -1,7 +1,8 @@
+import type { User } from '@prisma/client';
+
 import { STRIPE_CUSTOMER_TYPE } from '@documenso/lib/constants/billing';
 import { stripe } from '@documenso/lib/server-only/stripe';
 import { prisma } from '@documenso/prisma';
-import type { User } from '@documenso/prisma/client';
 
 import { onSubscriptionUpdated } from './webhook/on-subscription-updated';
 
@@ -31,7 +32,9 @@ export const getStripeCustomerById = async (stripeCustomerId: string) => {
  *
  * Will create a Stripe customer and update the relevant user if one does not exist.
  */
-export const getStripeCustomerByUser = async (user: User) => {
+export const getStripeCustomerByUser = async (
+  user: Pick<User, 'id' | 'customerId' | 'email' | 'name'>,
+) => {
   if (user.customerId) {
     const stripeCustomer = await getStripeCustomerById(user.customerId);
 

packages/ee/server-only/stripe/get-prices-by-plan.ts

@@ -4,15 +4,14 @@ import { stripe } from '@documenso/lib/server-only/stripe';
 type PlanType = (typeof STRIPE_PLAN_TYPE)[keyof typeof STRIPE_PLAN_TYPE];
 
 export const getPricesByPlan = async (plan: PlanType | PlanType[]) => {
-  const planTypes = typeof plan === 'string' ? [plan] : plan;
+  const planTypes: string[] = typeof plan === 'string' ? [plan] : plan;
 
-  const query = planTypes.map((planType) => `metadata['plan']:'${planType}'`).join(' OR ');
-
-  const { data: prices } = await stripe.prices.search({
-    query,
+  const prices = await stripe.prices.list({
     expand: ['data.product'],
     limit: 100,
   });
 
-  return prices.filter((price) => price.type === 'recurring');
+  return prices.data.filter(
+    (price) => price.type === 'recurring' && planTypes.includes(price.metadata.plan),
+  );
 };

packages/ee/server-only/stripe/transfer-team-subscription.ts

@@ -1,10 +1,10 @@
+import { type Subscription, type Team, type User } from '@prisma/client';
 import type Stripe from 'stripe';
 
 import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { stripe } from '@documenso/lib/server-only/stripe';
 import { subscriptionsContainsActivePlan } from '@documenso/lib/utils/billing';
 import { prisma } from '@documenso/prisma';
-import { type Subscription, type Team, type User } from '@documenso/prisma/client';
 
 import { deleteCustomerPaymentMethods } from './delete-customer-payment-methods';
 import { getTeamPrices } from './get-team-prices';

packages/ee/server-only/stripe/webhook/handler.ts

@@ -16,7 +16,7 @@ type StripeWebhookResponse = {
   message: string;
 };
 
-export const stripeWebhookHandler = async (req: Request) => {
+export const stripeWebhookHandler = async (req: Request): Promise<Response> => {
   try {
     const isBillingEnabled = IS_BILLING_ENABLED();
 
@@ -51,17 +51,21 @@ export const stripeWebhookHandler = async (req: Request) => {
       );
     }
 
-    // Todo: I'm not sure about this.
-    const clonedReq = req.clone();
-    const rawBody = await clonedReq.arrayBuffer();
-    const body = Buffer.from(rawBody);
+    const payload = await req.text();
 
-    // It was this:
-    // const body = await buffer(req);
+    if (!payload) {
+      return Response.json(
+        {
+          success: false,
+          message: 'No payload found in request',
+        } satisfies StripeWebhookResponse,
+        { status: 400 },
+      );
+    }
 
-    const event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+    const event = stripe.webhooks.constructEvent(payload, signature, webhookSecret);
 
-    await match(event.type)
+    return await match(event.type)
       .with('checkout.session.completed', async () => {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const session = event.data.object as Stripe.Checkout.Session;

packages/ee/server-only/stripe/webhook/on-subscription-deleted.ts

@@ -1,6 +1,7 @@
+import { SubscriptionStatus } from '@prisma/client';
+
 import type { Stripe } from '@documenso/lib/server-only/stripe';
 import { prisma } from '@documenso/prisma';
-import { SubscriptionStatus } from '@documenso/prisma/client';
 
 export type OnSubscriptionDeletedOptions = {
   subscription: Stripe.Subscription;

packages/ee/server-only/stripe/webhook/on-subscription-updated.ts

@@ -1,9 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import { SubscriptionStatus } from '@prisma/client';
 import { match } from 'ts-pattern';
 
 import type { Stripe } from '@documenso/lib/server-only/stripe';
 import { prisma } from '@documenso/prisma';
-import type { Prisma } from '@documenso/prisma/client';
-import { SubscriptionStatus } from '@documenso/prisma/client';
 
 export type OnSubscriptionUpdatedOptions = {
   userId?: number;

packages/ee/server-only/util/is-community-plan.ts

@@ -0,0 +1,57 @@
+import type { Subscription } from '@prisma/client';
+
+import { subscriptionsContainsActivePlan } from '@documenso/lib/utils/billing';
+import { prisma } from '@documenso/prisma';
+
+import { getCommunityPlanPriceIds } from '../stripe/get-community-plan-prices';
+
+export type IsCommunityPlanOptions = {
+  userId: number;
+  teamId?: number;
+};
+
+/**
+ * Whether the user or team is on the community plan.
+ */
+export const isCommunityPlan = async ({
+  userId,
+  teamId,
+}: IsCommunityPlanOptions): Promise<boolean> => {
+  let subscriptions: Subscription[] = [];
+
+  if (teamId) {
+    subscriptions = await prisma.team
+      .findFirstOrThrow({
+        where: {
+          id: teamId,
+        },
+        select: {
+          owner: {
+            include: {
+              subscriptions: true,
+            },
+          },
+        },
+      })
+      .then((team) => team.owner.subscriptions);
+  } else {
+    subscriptions = await prisma.user
+      .findFirstOrThrow({
+        where: {
+          id: userId,
+        },
+        select: {
+          subscriptions: true,
+        },
+      })
+      .then((user) => user.subscriptions);
+  }
+
+  if (subscriptions.length === 0) {
+    return false;
+  }
+
+  const communityPlanPriceIds = await getCommunityPlanPriceIds();
+
+  return subscriptionsContainsActivePlan(subscriptions, communityPlanPriceIds);
+};

packages/ee/server-only/util/is-document-enterprise.ts

@@ -1,7 +1,8 @@
+import type { Subscription } from '@prisma/client';
+
 import { IS_BILLING_ENABLED } from '@documenso/lib/constants/app';
 import { subscriptionsContainsActivePlan } from '@documenso/lib/utils/billing';
 import { prisma } from '@documenso/prisma';
-import type { Subscription } from '@documenso/prisma/client';
 
 import { getEnterprisePlanPriceIds } from '../stripe/get-enterprise-plan-prices';
 

packages/ee/server-only/util/is-document-platform.ts

@@ -1,7 +1,8 @@
+import type { Document, Subscription } from '@prisma/client';
+
 import { IS_BILLING_ENABLED } from '@documenso/lib/constants/app';
 import { subscriptionsContainsActivePlan } from '@documenso/lib/utils/billing';
 import { prisma } from '@documenso/prisma';
-import type { Document, Subscription } from '@documenso/prisma/client';
 
 import { getPlatformPlanPriceIds } from '../stripe/get-platform-plan-prices';
 

packages/email/template-components/template-document-cancel.tsx

@@ -8,12 +8,14 @@ export interface TemplateDocumentCancelProps {
   inviterEmail: string;
   documentName: string;
   assetBaseUrl: string;
+  cancellationReason?: string;
 }
 
 export const TemplateDocumentCancel = ({
   inviterName,
   documentName,
   assetBaseUrl,
+  cancellationReason,
 }: TemplateDocumentCancelProps) => {
   return (
     <>
@@ -34,6 +36,12 @@ export const TemplateDocumentCancel = ({
         <Text className="my-1 text-center text-base text-slate-400">
           <Trans>You don't need to sign it anymore.</Trans>
         </Text>
+
+        {cancellationReason && (
+          <Text className="mt-4 text-center text-base">
+            <Trans>Reason for cancellation: {cancellationReason}</Trans>
+          </Text>
+        )}
       </Section>
     </>
   );

packages/email/template-components/template-document-invite.tsx

@@ -2,10 +2,10 @@ import { useMemo } from 'react';
 
 import { useLingui } from '@lingui/react';
 import { Trans } from '@lingui/react/macro';
+import { RecipientRole } from '@prisma/client';
 import { P, match } from 'ts-pattern';
 
 import { RECIPIENT_ROLES_DESCRIPTION } from '@documenso/lib/constants/recipient-roles';
-import { RecipientRole } from '@documenso/prisma/client';
 
 import { Button, Section, Text } from '../components';
 import { TemplateDocumentImage } from './template-document-image';

packages/email/templates/document-cancel.tsx

@@ -14,6 +14,7 @@ export const DocumentCancelTemplate = ({
   inviterEmail = 'lucas@documenso.com',
   documentName = 'Open Source Pledge.pdf',
   assetBaseUrl = 'http://localhost:3002',
+  cancellationReason,
 }: DocumentCancelEmailTemplateProps) => {
   const { _ } = useLingui();
   const branding = useBranding();
@@ -48,6 +49,7 @@ export const DocumentCancelTemplate = ({
                 inviterEmail={inviterEmail}
                 documentName={documentName}
                 assetBaseUrl={assetBaseUrl}
+                cancellationReason={cancellationReason}
               />
             </Section>
           </Container>

packages/email/templates/document-created-from-direct-template.tsx

@@ -1,9 +1,9 @@
 import { msg } from '@lingui/core/macro';
 import { useLingui } from '@lingui/react';
 import { Trans } from '@lingui/react/macro';
+import { RecipientRole } from '@prisma/client';
 
 import { RECIPIENT_ROLES_DESCRIPTION } from '@documenso/lib/constants/recipient-roles';
-import { RecipientRole } from '@documenso/prisma/client';
 
 import { Body, Button, Container, Head, Html, Img, Preview, Section, Text } from '../components';
 import { useBranding } from '../providers/branding';

packages/email/templates/document-invite.tsx

@@ -1,9 +1,9 @@
 import { msg } from '@lingui/core/macro';
 import { useLingui } from '@lingui/react';
 import { Trans } from '@lingui/react/macro';
+import type { RecipientRole } from '@prisma/client';
 
 import { RECIPIENT_ROLES_DESCRIPTION } from '@documenso/lib/constants/recipient-roles';
-import type { RecipientRole } from '@documenso/prisma/client';
 
 import { Body, Container, Head, Hr, Html, Img, Link, Preview, Section, Text } from '../components';
 import { useBranding } from '../providers/branding';

packages/lib/client-only/hooks/use-analytics.ts

@@ -20,6 +20,20 @@ export function useAnalytics() {
     posthog.capture(event, properties);
   };
 
+  /**
+   * Capture an analytic event.
+   *
+   * @param error The error to capture.
+   * @param properties Properties to attach to the event.
+   */
+  const captureException = (error: Error, properties?: Record<string, unknown>) => {
+    if (!isPostHogEnabled) {
+      return;
+    }
+
+    posthog.captureException(error, properties);
+  };
+
   /**
    * Start the session recording.
    *
@@ -53,6 +67,7 @@ export function useAnalytics() {
 
   return {
     capture,
+    captureException,
     startSessionRecording,
     stopSessionRecording,
   };

packages/lib/client-only/providers/session.tsx

@@ -1,12 +1,12 @@
 import { createContext, useCallback, useContext, useEffect, useState } from 'react';
 import React from 'react';
 
+import type { Session } from '@prisma/client';
 import { useLocation } from 'react-router';
 
 import { authClient } from '@documenso/auth/client';
 import type { SessionUser } from '@documenso/auth/server/lib/session/session';
 import { type TGetTeamsResponse } from '@documenso/lib/server-only/team/get-teams';
-import type { Session } from '@documenso/prisma/client';
 import { trpc } from '@documenso/trpc/client';
 
 export type AppSession = {
@@ -22,7 +22,7 @@ interface SessionProviderProps {
 
 interface SessionContextValue {
   sessionData: AppSession | null;
-  refresh: () => Promise<void>;
+  refreshSession: () => Promise<void>;
 }
 
 const SessionContext = createContext<SessionContextValue | null>(null);
@@ -40,7 +40,7 @@ export const useSession = () => {
 
   return {
     ...context.sessionData,
-    refresh: context.refresh,
+    refreshSession: context.refreshSession,
   };
 };
 
@@ -68,7 +68,7 @@ export const SessionProvider = ({ children, initialSession }: SessionProviderPro
     }
 
     const teams = await trpc.team.getTeams.query().catch(() => {
-      // Todo: Log
+      // Todo: (RR7) Log
       return [];
     });
 
@@ -102,7 +102,7 @@ export const SessionProvider = ({ children, initialSession }: SessionProviderPro
     <SessionContext.Provider
       value={{
         sessionData: session,
-        refresh: refreshSession,
+        refreshSession,
       }}
     >
       {children}

packages/lib/constants/app.ts

@@ -6,9 +6,6 @@ export const APP_DOCUMENT_UPLOAD_SIZE_LIMIT =
 export const NEXT_PUBLIC_WEBAPP_URL = () =>
   env('NEXT_PUBLIC_WEBAPP_URL') ?? 'http://localhost:3000';
 
-export const NEXT_PUBLIC_MARKETING_URL = () =>
-  env('NEXT_PUBLIC_MARKETING_URL') ?? 'http://localhost:3001';
-
 export const NEXT_PRIVATE_INTERNAL_WEBAPP_URL =
   env('NEXT_PRIVATE_INTERNAL_WEBAPP_URL') ?? NEXT_PUBLIC_WEBAPP_URL();
 

packages/lib/constants/document.ts

@@ -8,6 +8,9 @@ export const DOCUMENT_STATUS: {
   [DocumentStatus.COMPLETED]: {
     description: msg`Completed`,
   },
+  [DocumentStatus.REJECTED]: {
+    description: msg`Rejected`,
+  },
   [DocumentStatus.DRAFT]: {
     description: msg`Draft`,
   },
@@ -31,3 +34,29 @@ export const DOCUMENT_DISTRIBUTION_METHODS: Record<string, DocumentDistributionM
     description: msg`None`,
   },
 } satisfies Record<DocumentDistributionMethod, DocumentDistributionMethodTypeData>;
+
+export enum DocumentSignatureType {
+  DRAW = 'draw',
+  TYPE = 'type',
+  UPLOAD = 'upload',
+}
+
+type DocumentSignatureTypeData = {
+  label: MessageDescriptor;
+  value: DocumentSignatureType;
+};
+
+export const DOCUMENT_SIGNATURE_TYPES = {
+  [DocumentSignatureType.DRAW]: {
+    label: msg`Draw`,
+    value: DocumentSignatureType.DRAW,
+  },
+  [DocumentSignatureType.TYPE]: {
+    label: msg`Type`,
+    value: DocumentSignatureType.TYPE,
+  },
+  [DocumentSignatureType.UPLOAD]: {
+    label: msg`Upload`,
+    value: DocumentSignatureType.UPLOAD,
+  },
+} satisfies Record<DocumentSignatureType, DocumentSignatureTypeData>;

packages/lib/constants/signatures.ts

@@ -0,0 +1,4 @@
+export const SIGNATURE_CANVAS_DPI = 2;
+export const SIGNATURE_MIN_COVERAGE_THRESHOLD = 0.01;
+
+export const isBase64Image = (value: string) => value.startsWith('data:image/png;base64,');

packages/lib/jobs/client.ts

@@ -1,5 +1,6 @@
 import { JobClient } from './client/client';
 import { SEND_CONFIRMATION_EMAIL_JOB_DEFINITION } from './definitions/emails/send-confirmation-email';
+import { SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION } from './definitions/emails/send-document-cancelled-emails';
 import { SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION } from './definitions/emails/send-password-reset-success-email';
 import { SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION } from './definitions/emails/send-recipient-signed-email';
 import { SEND_SIGNING_REJECTION_EMAILS_JOB_DEFINITION } from './definitions/emails/send-rejection-emails';
@@ -24,6 +25,7 @@ export const jobsClient = new JobClient([
   SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION,
   SEND_SIGNING_REJECTION_EMAILS_JOB_DEFINITION,
   SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION,
+  SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION,
   BULK_SEND_TEMPLATE_JOB_DEFINITION,
 ] as const);
 

packages/lib/jobs/client/inngest.ts

@@ -71,28 +71,6 @@ export class InngestJobProvider extends BaseJobProvider {
     });
   }
 
-  // public getApiHandler() {
-  //   const handler = createPagesRoute({
-  //     client: this._client,
-  //     functions: this._functions,
-  //   });
-
-  //   return async (req: NextApiRequest, res: NextApiResponse) => {
-  //     // Since body-parser is disabled for this route we need to patch in the parsed body
-  //     if (req.headers['content-type'] === 'application/json') {
-  //       Object.assign(req, {
-  //         body: await json(req),
-  //       });
-  //     }
-
-  //     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  //     const nextReq = req as unknown as NextRequest;
-
-  //     return await handler(nextReq, res);
-  //   };
-  // }
-
-  // Todo: Do we need to handle the above?
   public getApiHandler() {
     return async (context: HonoContext) => {
       const handler = createHonoPagesRoute({

packages/lib/jobs/definitions/emails/send-document-cancelled-emails.handler.ts

@@ -0,0 +1,105 @@
+import { createElement } from 'react';
+
+import { msg } from '@lingui/core/macro';
+import { ReadStatus, SendStatus, SigningStatus } from '@prisma/client';
+
+import { mailer } from '@documenso/email/mailer';
+import DocumentCancelTemplate from '@documenso/email/templates/document-cancel';
+import { prisma } from '@documenso/prisma';
+
+import { getI18nInstance } from '../../../client-only/providers/i18n-server';
+import { NEXT_PUBLIC_WEBAPP_URL } from '../../../constants/app';
+import { FROM_ADDRESS, FROM_NAME } from '../../../constants/email';
+import { extractDerivedDocumentEmailSettings } from '../../../types/document-email';
+import { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';
+import { teamGlobalSettingsToBranding } from '../../../utils/team-global-settings-to-branding';
+import type { JobRunIO } from '../../client/_internal/job';
+import type { TSendDocumentCancelledEmailsJobDefinition } from './send-document-cancelled-emails';
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TSendDocumentCancelledEmailsJobDefinition;
+  io: JobRunIO;
+}) => {
+  const { documentId, cancellationReason } = payload;
+
+  const document = await prisma.document.findFirstOrThrow({
+    where: {
+      id: documentId,
+    },
+    include: {
+      user: true,
+      documentMeta: true,
+      recipients: true,
+      team: {
+        select: {
+          teamEmail: true,
+          name: true,
+          url: true,
+          teamGlobalSettings: true,
+        },
+      },
+    },
+  });
+
+  const { documentMeta, user: documentOwner } = document;
+
+  // Check if document cancellation emails are enabled
+  const isEmailEnabled = extractDerivedDocumentEmailSettings(documentMeta).documentDeleted;
+
+  if (!isEmailEnabled) {
+    return;
+  }
+
+  const i18n = await getI18nInstance(documentMeta?.language);
+
+  // Send cancellation emails to all recipients who have been sent the document or viewed it
+  const recipientsToNotify = document.recipients.filter(
+    (recipient) =>
+      (recipient.sendStatus === SendStatus.SENT || recipient.readStatus === ReadStatus.OPENED) &&
+      recipient.signingStatus !== SigningStatus.REJECTED,
+  );
+
+  await io.runTask('send-cancellation-emails', async () => {
+    await Promise.all(
+      recipientsToNotify.map(async (recipient) => {
+        const template = createElement(DocumentCancelTemplate, {
+          documentName: document.title,
+          inviterName: documentOwner.name || undefined,
+          inviterEmail: documentOwner.email,
+          assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+          cancellationReason: cancellationReason || 'The document has been cancelled.',
+        });
+
+        const branding = document.team?.teamGlobalSettings
+          ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
+          : undefined;
+
+        const [html, text] = await Promise.all([
+          renderEmailWithI18N(template, { lang: documentMeta?.language, branding }),
+          renderEmailWithI18N(template, {
+            lang: documentMeta?.language,
+            branding,
+            plainText: true,
+          }),
+        ]);
+
+        await mailer.sendMail({
+          to: {
+            name: recipient.name,
+            address: recipient.email,
+          },
+          from: {
+            name: FROM_NAME,
+            address: FROM_ADDRESS,
+          },
+          subject: i18n._(msg`Document "${document.title}" Cancelled`),
+          html,
+          text,
+        });
+      }),
+    );
+  });
+};

packages/lib/jobs/definitions/emails/send-document-cancelled-emails.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+import { type JobDefinition } from '../../client/_internal/job';
+
+const SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_ID = 'send.document.cancelled.emails';
+
+const SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_SCHEMA = z.object({
+  documentId: z.number(),
+  cancellationReason: z.string().optional(),
+  requestMetadata: z.any().optional(),
+});
+
+export type TSendDocumentCancelledEmailsJobDefinition = z.infer<
+  typeof SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_SCHEMA
+>;
+
+export const SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION = {
+  id: SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_ID,
+  name: 'Send Document Cancelled Emails',
+  version: '1.0.0',
+  trigger: {
+    name: SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_ID,
+    schema: SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./send-document-cancelled-emails.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION_ID,
+  TSendDocumentCancelledEmailsJobDefinition
+>;

packages/lib/jobs/definitions/emails/send-team-deleted-email.ts

@@ -23,6 +23,8 @@ const SEND_TEAM_DELETED_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
         brandingHidePoweredBy: z.boolean(),
         teamId: z.number(),
         typedSignatureEnabled: z.boolean(),
+        uploadSignatureEnabled: z.boolean(),
+        drawSignatureEnabled: z.boolean(),
       })
       .nullish(),
   }),

packages/lib/jobs/definitions/internal/bulk-send-template.handler.ts

@@ -1,6 +1,7 @@
 import { createElement } from 'react';
 
 import { msg } from '@lingui/macro';
+import type { TeamGlobalSettings } from '@prisma/client';
 import { parse } from 'csv-parse/sync';
 import { z } from 'zod';
 
@@ -10,7 +11,6 @@ import { sendDocument } from '@documenso/lib/server-only/document/send-document'
 import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
 import { getTemplateById } from '@documenso/lib/server-only/template/get-template-by-id';
 import { prisma } from '@documenso/prisma';
-import type { TeamGlobalSettings } from '@documenso/prisma/client';
 
 import { getI18nInstance } from '../../../client-only/providers/i18n-server';
 import { NEXT_PUBLIC_WEBAPP_URL } from '../../../constants/app';

packages/lib/jobs/definitions/internal/seal-document.handler.ts

@@ -6,9 +6,11 @@ import { PDFDocument } from 'pdf-lib';
 import { prisma } from '@documenso/prisma';
 import { signPdf } from '@documenso/signing';
 
+import { AppError, AppErrorCode } from '../../../errors/app-error';
 import { sendCompletedEmail } from '../../../server-only/document/send-completed-email';
 import PostHogServerClient from '../../../server-only/feature-flags/get-post-hog-server-client';
 import { getCertificatePdf } from '../../../server-only/htmltopdf/get-certificate-pdf';
+import { addRejectionStampToPdf } from '../../../server-only/pdf/add-rejection-stamp-to-pdf';
 import { flattenAnnotations } from '../../../server-only/pdf/flatten-annotations';
 import { flattenForm } from '../../../server-only/pdf/flatten-form';
 import { insertFieldInPDF } from '../../../server-only/pdf/insert-field-in-pdf';
@@ -22,6 +24,7 @@ import {
 import { getFileServerSide } from '../../../universal/upload/get-file.server';
 import { putPdfFileServerSide } from '../../../universal/upload/put-file.server';
 import { fieldsContainUnsignedRequiredField } from '../../../utils/advanced-fields-helpers';
+import { isDocumentCompleted } from '../../../utils/document';
 import { createDocumentAuditLogData } from '../../../utils/document-audit-logs';
 import type { JobRunIO } from '../../client/_internal/job';
 import type { TSealDocumentJobDefinition } from './seal-document';
@@ -38,11 +41,6 @@ export const run = async ({
   const document = await prisma.document.findFirstOrThrow({
     where: {
       id: documentId,
-      recipients: {
-        every: {
-          signingStatus: SigningStatus.SIGNED,
-        },
-      },
     },
     include: {
       documentMeta: true,
@@ -59,6 +57,16 @@ export const run = async ({
     },
   });
 
+  const isComplete =
+    document.recipients.some((recipient) => recipient.signingStatus === SigningStatus.REJECTED) ||
+    document.recipients.every((recipient) => recipient.signingStatus === SigningStatus.SIGNED);
+
+  if (!isComplete) {
+    throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+      message: 'Document is not complete',
+    });
+  }
+
   // Seems silly but we need to do this in case the job is re-ran
   // after it has already run through the update task further below.
   // eslint-disable-next-line @typescript-eslint/require-await
@@ -91,9 +99,15 @@ export const run = async ({
     },
   });
 
-  if (recipients.some((recipient) => recipient.signingStatus !== SigningStatus.SIGNED)) {
-    throw new Error(`Document ${document.id} has unsigned recipients`);
-  }
+  // Determine if the document has been rejected by checking if any recipient has rejected it
+  const rejectedRecipient = recipients.find(
+    (recipient) => recipient.signingStatus === SigningStatus.REJECTED,
+  );
+
+  const isRejected = Boolean(rejectedRecipient);
+
+  // Get the rejection reason from the rejected recipient
+  const rejectionReason = rejectedRecipient?.rejectionReason ?? '';
 
   const fields = await prisma.field.findMany({
     where: {
@@ -104,7 +118,8 @@ export const run = async ({
     },
   });
 
-  if (fieldsContainUnsignedRequiredField(fields)) {
+  // Skip the field check if the document is rejected
+  if (!isRejected && fieldsContainUnsignedRequiredField(fields)) {
     throw new Error(`Document ${document.id} has unsigned required fields`);
   }
 
@@ -132,6 +147,11 @@ export const run = async ({
     flattenForm(pdfDoc);
     flattenAnnotations(pdfDoc);
 
+    // Add rejection stamp if the document is rejected
+    if (isRejected && rejectionReason) {
+      await addRejectionStampToPdf(pdfDoc, rejectionReason);
+    }
+
     if (certificateData) {
       const certificateDoc = await PDFDocument.load(certificateData);
 
@@ -160,8 +180,11 @@ export const run = async ({
 
     const { name } = path.parse(document.title);
 
+    // Add suffix based on document status
+    const suffix = isRejected ? '_rejected.pdf' : '_signed.pdf';
+
     const documentData = await putPdfFileServerSide({
-      name: `${name}_signed.pdf`,
+      name: `${name}${suffix}`,
       type: 'application/pdf',
       arrayBuffer: async () => Promise.resolve(pdfBuffer),
     });
@@ -177,6 +200,7 @@ export const run = async ({
       event: 'App: Document Sealed',
       properties: {
         documentId: document.id,
+        isRejected,
       },
     });
   }
@@ -194,7 +218,7 @@ export const run = async ({
           id: document.id,
         },
         data: {
-          status: DocumentStatus.COMPLETED,
+          status: isRejected ? DocumentStatus.REJECTED : DocumentStatus.COMPLETED,
           completedAt: new Date(),
         },
       });
@@ -216,6 +240,7 @@ export const run = async ({
           user: null,
           data: {
             transactionId: nanoid(),
+            ...(isRejected ? { isRejected: true, rejectionReason: rejectionReason } : {}),
           },
         }),
       });
@@ -223,9 +248,9 @@ export const run = async ({
   });
 
   await io.runTask('send-completed-email', async () => {
-    let shouldSendCompletedEmail = sendEmail && !isResealing;
+    let shouldSendCompletedEmail = sendEmail && !isResealing && !isRejected;
 
-    if (isResealing && documentStatus !== DocumentStatus.COMPLETED) {
+    if (isResealing && !isDocumentCompleted(document.status)) {
       shouldSendCompletedEmail = sendEmail;
     }
 
@@ -246,7 +271,9 @@ export const run = async ({
   });
 
   await triggerWebhook({
-    event: WebhookTriggerEvents.DOCUMENT_COMPLETED,
+    event: isRejected
+      ? WebhookTriggerEvents.DOCUMENT_REJECTED
+      : WebhookTriggerEvents.DOCUMENT_COMPLETED,
     data: ZWebhookDocumentSchema.parse(mapDocumentToWebhookDocumentPayload(updatedDocument)),
     userId: updatedDocument.userId,
     teamId: updatedDocument.teamId ?? undefined,

packages/lib/package.json

@@ -45,6 +45,7 @@
     "pdf-lib": "^1.17.1",
     "pg": "^8.11.3",
     "playwright": "1.43.0",
+    "posthog-js": "^1.224.0",
     "react": "^18",
     "remeda": "^2.17.3",
     "sharp": "0.32.6",

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

@@ -13,6 +13,7 @@ export const getDocumentStats = async () => {
     [ExtendedDocumentStatus.DRAFT]: 0,
     [ExtendedDocumentStatus.PENDING]: 0,
     [ExtendedDocumentStatus.COMPLETED]: 0,
+    [ExtendedDocumentStatus.REJECTED]: 0,
     [ExtendedDocumentStatus.ALL]: 0,
   };
 

packages/lib/server-only/admin/get-signing-volume.ts

@@ -1,4 +1,4 @@
-import { DocumentStatus } from '@prisma/client';
+import { DocumentStatus, SubscriptionStatus } from '@prisma/client';
 
 import { kyselyPrisma, sql } from '@documenso/prisma';
 
@@ -44,7 +44,6 @@ export async function getSigningVolume({
         .on('td.status', '=', sql.lit(DocumentStatus.COMPLETED))
         .on('td.deletedAt', 'is', null),
     )
-    // @ts-expect-error - Raw SQL enum casting not properly typed by Kysely
     .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
     .where((eb) =>
       eb.or([
@@ -82,7 +81,6 @@ export async function getSigningVolume({
     .selectFrom('Subscription as s')
     .leftJoin('User as u', 's.userId', 'u.id')
     .leftJoin('Team as t', 's.teamId', 't.id')
-    // @ts-expect-error - Raw SQL enum casting not properly typed by Kysely
     .where(sql`s.status = ${SubscriptionStatus.ACTIVE}::"SubscriptionStatus"`)
     .where((eb) =>
       eb.or([

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

@@ -26,6 +26,8 @@ export type CreateDocumentMetaOptions = {
   signingOrder?: DocumentSigningOrder;
   distributionMethod?: DocumentDistributionMethod;
   typedSignatureEnabled?: boolean;
+  uploadSignatureEnabled?: boolean;
+  drawSignatureEnabled?: boolean;
   language?: SupportedLanguageCodes;
   requestMetadata: ApiRequestMetadata;
 };
@@ -44,6 +46,8 @@ export const upsertDocumentMeta = async ({
   emailSettings,
   distributionMethod,
   typedSignatureEnabled,
+  uploadSignatureEnabled,
+  drawSignatureEnabled,
   language,
   requestMetadata,
 }: CreateDocumentMetaOptions) => {
@@ -96,6 +100,8 @@ export const upsertDocumentMeta = async ({
         emailSettings,
         distributionMethod,
         typedSignatureEnabled,
+        uploadSignatureEnabled,
+        drawSignatureEnabled,
         language,
       },
       update: {
@@ -109,6 +115,8 @@ export const upsertDocumentMeta = async ({
         emailSettings,
         distributionMethod,
         typedSignatureEnabled,
+        uploadSignatureEnabled,
+        drawSignatureEnabled,
         language,
       },
     });

packages/lib/server-only/document/complete-document-with-token.ts

@@ -13,6 +13,7 @@ import { fieldsContainUnsignedRequiredField } from '@documenso/lib/utils/advance
 import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
 import { prisma } from '@documenso/prisma';
 
+import { AppError, AppErrorCode } from '../../errors/app-error';
 import { jobs } from '../../jobs/client';
 import type { TRecipientActionAuth } from '../../types/document-auth';
 import {
@@ -73,6 +74,13 @@ export const completeDocumentWithToken = async ({
     throw new Error(`Recipient ${recipient.id} has already signed`);
   }
 
+  if (recipient.signingStatus === SigningStatus.REJECTED) {
+    throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
+      message: 'Recipient has already rejected the document',
+      statusCode: 400,
+    });
+  }
+
   if (document.documentMeta?.signingOrder === DocumentSigningOrder.SEQUENTIAL) {
     const isRecipientsTurn = await getIsRecipientsTurnToSign({ token: recipient.token });
 

packages/lib/server-only/document/create-document-v2.ts

@@ -158,6 +158,10 @@ export const createDocumentV2 = async ({
             language: meta?.language || team?.teamGlobalSettings?.documentLanguage,
             typedSignatureEnabled:
               meta?.typedSignatureEnabled ?? team?.teamGlobalSettings?.typedSignatureEnabled,
+            uploadSignatureEnabled:
+              meta?.uploadSignatureEnabled ?? team?.teamGlobalSettings?.uploadSignatureEnabled,
+            drawSignatureEnabled:
+              meta?.drawSignatureEnabled ?? team?.teamGlobalSettings?.drawSignatureEnabled,
           },
         },
       },

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

@@ -128,8 +128,10 @@ export const createDocument = async ({
         documentMeta: {
           create: {
             language: team?.teamGlobalSettings?.documentLanguage,
-            typedSignatureEnabled: team?.teamGlobalSettings?.typedSignatureEnabled,
             timezone: timezone,
+            typedSignatureEnabled: team?.teamGlobalSettings?.typedSignatureEnabled ?? true,
+            uploadSignatureEnabled: team?.teamGlobalSettings?.uploadSignatureEnabled ?? true,
+            drawSignatureEnabled: team?.teamGlobalSettings?.drawSignatureEnabled ?? true,
           },
         },
       },

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

@@ -26,6 +26,7 @@ import {
   mapDocumentToWebhookDocumentPayload,
 } from '../../types/webhook-payload';
 import type { ApiRequestMetadata } from '../../universal/extract-request-metadata';
+import { isDocumentCompleted } from '../../utils/document';
 import { createDocumentAuditLogData } from '../../utils/document-audit-logs';
 import { renderEmailWithI18N } from '../../utils/render-email-with-i18n';
 import { teamGlobalSettingsToBranding } from '../../utils/team-global-settings-to-branding';
@@ -161,7 +162,7 @@ const handleDocumentOwnerDelete = async ({
   }
 
   // Soft delete completed documents.
-  if (document.status === DocumentStatus.COMPLETED) {
+  if (isDocumentCompleted(document.status)) {
     return await prisma.$transaction(async (tx) => {
       await tx.documentAuditLog.create({
         data: createDocumentAuditLogData({

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

@@ -81,6 +81,7 @@ export const findDocuments = async ({
   const searchFilter: Prisma.DocumentWhereInput = {
     OR: [
       { title: { contains: query, mode: 'insensitive' } },
+      { externalId: { contains: query, mode: 'insensitive' } },
       { recipients: { some: { name: { contains: query, mode: 'insensitive' } } } },
       { recipients: { some: { email: { contains: query, mode: 'insensitive' } } } },
     ],
@@ -355,6 +356,24 @@ const findDocumentsFilter = (status: ExtendedDocumentStatus, user: User) => {
         },
       ],
     }))
+    .with(ExtendedDocumentStatus.REJECTED, () => ({
+      OR: [
+        {
+          userId: user.id,
+          teamId: null,
+          status: ExtendedDocumentStatus.REJECTED,
+        },
+        {
+          status: ExtendedDocumentStatus.REJECTED,
+          recipients: {
+            some: {
+              email: user.email,
+              signingStatus: SigningStatus.REJECTED,
+            },
+          },
+        },
+      ],
+    }))
     .exhaustive();
 };
 
@@ -547,5 +566,38 @@ const findTeamDocumentsFilter = (
 
       return filter;
     })
+    .with(ExtendedDocumentStatus.REJECTED, () => {
+      const filter: Prisma.DocumentWhereInput = {
+        status: ExtendedDocumentStatus.REJECTED,
+        OR: [
+          {
+            teamId: team.id,
+            OR: visibilityFilters,
+          },
+        ],
+      };
+
+      if (teamEmail && filter.OR) {
+        filter.OR.push(
+          {
+            recipients: {
+              some: {
+                email: teamEmail,
+                signingStatus: SigningStatus.REJECTED,
+              },
+            },
+            OR: visibilityFilters,
+          },
+          {
+            user: {
+              email: teamEmail,
+            },
+            OR: visibilityFilters,
+          },
+        );
+      }
+
+      return filter;
+    })
     .exhaustive();
 };

packages/lib/server-only/document/get-document-certificate-audit-logs.ts

@@ -16,6 +16,7 @@ export const getDocumentCertificateAuditLogs = async ({
       type: {
         in: [
           DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_RECIPIENT_COMPLETED,
+          DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_RECIPIENT_REJECTED,
           DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_OPENED,
           DOCUMENT_AUDIT_LOG_TYPE.EMAIL_SENT,
         ],
@@ -29,6 +30,9 @@ export const getDocumentCertificateAuditLogs = async ({
     [DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_RECIPIENT_COMPLETED]: auditLogs.filter(
       (log) => log.type === DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_RECIPIENT_COMPLETED,
     ),
+    [DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_RECIPIENT_REJECTED]: auditLogs.filter(
+      (log) => log.type === DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_RECIPIENT_REJECTED,
+    ),
     [DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_OPENED]: auditLogs.filter(
       (log) => log.type === DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_OPENED,
     ),

packages/lib/server-only/document/get-recipient-or-sender-by-share-link-slug.ts

@@ -34,7 +34,9 @@ export const getRecipientOrSenderByShareLinkSlug = async ({
       documentId,
       email,
     },
-    include: {
+    select: {
+      email: true,
+      name: true,
       signatures: true,
     },
   });

packages/lib/server-only/document/get-stats.ts

@@ -44,6 +44,7 @@ export const getStats = async ({ user, period, search = '', ...options }: GetSta
     [ExtendedDocumentStatus.DRAFT]: 0,
     [ExtendedDocumentStatus.PENDING]: 0,
     [ExtendedDocumentStatus.COMPLETED]: 0,
+    [ExtendedDocumentStatus.REJECTED]: 0,
     [ExtendedDocumentStatus.INBOX]: 0,
     [ExtendedDocumentStatus.ALL]: 0,
   };
@@ -64,6 +65,10 @@ export const getStats = async ({ user, period, search = '', ...options }: GetSta
     if (stat.status === ExtendedDocumentStatus.PENDING) {
       stats[ExtendedDocumentStatus.PENDING] += stat._count._all;
     }
+
+    if (stat.status === ExtendedDocumentStatus.REJECTED) {
+      stats[ExtendedDocumentStatus.REJECTED] += stat._count._all;
+    }
   });
 
   Object.keys(stats).forEach((key) => {

packages/lib/server-only/document/reject-document-with-token.ts

@@ -1,18 +1,12 @@
 import { SigningStatus } from '@prisma/client';
-import { WebhookTriggerEvents } from '@prisma/client';
 
 import { jobs } from '@documenso/lib/jobs/client';
 import { prisma } from '@documenso/prisma';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import { DOCUMENT_AUDIT_LOG_TYPE } from '../../types/document-audit-logs';
-import {
-  ZWebhookDocumentSchema,
-  mapDocumentToWebhookDocumentPayload,
-} from '../../types/webhook-payload';
 import type { RequestMetadata } from '../../universal/extract-request-metadata';
 import { createDocumentAuditLogData } from '../../utils/document-audit-logs';
-import { triggerWebhook } from '../webhooks/trigger/trigger-webhook';
 
 export type RejectDocumentWithTokenOptions = {
   token: string;
@@ -84,7 +78,16 @@ export async function rejectDocumentWithToken({
     }),
   ]);
 
-  // Send email notifications
+  // Trigger the seal document job to process the document asynchronously
+  await jobs.triggerJob({
+    name: 'internal.seal-document',
+    payload: {
+      documentId,
+      requestMetadata,
+    },
+  });
+
+  // Send email notifications to the rejecting recipient
   await jobs.triggerJob({
     name: 'send.signing.rejected.emails',
     payload: {
@@ -93,27 +96,14 @@ export async function rejectDocumentWithToken({
     },
   });
 
-  // Get the updated document with all recipients
-  const updatedDocument = await prisma.document.findFirst({
-    where: {
-      id: document.id,
+  // Send cancellation emails to other recipients
+  await jobs.triggerJob({
+    name: 'send.document.cancelled.emails',
+    payload: {
+      documentId,
+      cancellationReason: reason,
+      requestMetadata,
     },
-    include: {
-      recipients: true,
-      documentMeta: true,
-    },
-  });
-
-  if (!updatedDocument) {
-    throw new Error('Document not found after update');
-  }
-
-  // Trigger webhook for document rejection
-  await triggerWebhook({
-    event: WebhookTriggerEvents.DOCUMENT_REJECTED,
-    data: ZWebhookDocumentSchema.parse(mapDocumentToWebhookDocumentPayload(updatedDocument)),
-    userId: document.userId,
-    teamId: document.teamId ?? undefined,
   });
 
   return updatedRecipient;

packages/lib/server-only/document/resend-document.tsx

@@ -20,6 +20,7 @@ import { prisma } from '@documenso/prisma';
 import { getI18nInstance } from '../../client-only/providers/i18n-server';
 import { NEXT_PUBLIC_WEBAPP_URL } from '../../constants/app';
 import { extractDerivedDocumentEmailSettings } from '../../types/document-email';
+import { isDocumentCompleted } from '../../utils/document';
 import { renderEmailWithI18N } from '../../utils/render-email-with-i18n';
 import { teamGlobalSettingsToBranding } from '../../utils/team-global-settings-to-branding';
 import { getDocumentWhereInput } from './get-document-by-id';
@@ -88,7 +89,7 @@ export const resendDocument = async ({
     throw new Error('Can not send draft document');
   }
 
-  if (document.status === DocumentStatus.COMPLETED) {
+  if (isDocumentCompleted(document.status)) {
     throw new Error('Can not send completed document');
   }
 

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

@@ -18,6 +18,7 @@ import { getFileServerSide } from '../../universal/upload/get-file.server';
 import { putPdfFileServerSide } from '../../universal/upload/put-file.server';
 import { fieldsContainUnsignedRequiredField } from '../../utils/advanced-fields-helpers';
 import { getCertificatePdf } from '../htmltopdf/get-certificate-pdf';
+import { addRejectionStampToPdf } from '../pdf/add-rejection-stamp-to-pdf';
 import { flattenAnnotations } from '../pdf/flatten-annotations';
 import { flattenForm } from '../pdf/flatten-form';
 import { insertFieldInPDF } from '../pdf/insert-field-in-pdf';
@@ -41,11 +42,6 @@ export const sealDocument = async ({
   const document = await prisma.document.findFirstOrThrow({
     where: {
       id: documentId,
-      recipients: {
-        every: {
-          signingStatus: SigningStatus.SIGNED,
-        },
-      },
     },
     include: {
       documentData: true,
@@ -78,7 +74,21 @@ export const sealDocument = async ({
     },
   });
 
-  if (recipients.some((recipient) => recipient.signingStatus !== SigningStatus.SIGNED)) {
+  // Determine if the document has been rejected by checking if any recipient has rejected it
+  const rejectedRecipient = recipients.find(
+    (recipient) => recipient.signingStatus === SigningStatus.REJECTED,
+  );
+
+  const isRejected = Boolean(rejectedRecipient);
+
+  // Get the rejection reason from the rejected recipient
+  const rejectionReason = rejectedRecipient?.rejectionReason ?? '';
+
+  // If the document is not rejected, ensure all recipients have signed
+  if (
+    !isRejected &&
+    recipients.some((recipient) => recipient.signingStatus !== SigningStatus.SIGNED)
+  ) {
     throw new Error(`Document ${document.id} has unsigned recipients`);
   }
 
@@ -91,7 +101,8 @@ export const sealDocument = async ({
     },
   });
 
-  if (fieldsContainUnsignedRequiredField(fields)) {
+  // Skip the field check if the document is rejected
+  if (!isRejected && fieldsContainUnsignedRequiredField(fields)) {
     throw new Error(`Document ${document.id} has unsigned required fields`);
   }
 
@@ -119,6 +130,11 @@ export const sealDocument = async ({
   flattenForm(doc);
   flattenAnnotations(doc);
 
+  // Add rejection stamp if the document is rejected
+  if (isRejected && rejectionReason) {
+    await addRejectionStampToPdf(doc, rejectionReason);
+  }
+
   if (certificateData) {
     const certificate = await PDFDocument.load(certificateData);
 
@@ -142,8 +158,11 @@ export const sealDocument = async ({
 
   const { name } = path.parse(document.title);
 
+  // Add suffix based on document status
+  const suffix = isRejected ? '_rejected.pdf' : '_signed.pdf';
+
   const { data: newData } = await putPdfFileServerSide({
-    name: `${name}_signed.pdf`,
+    name: `${name}${suffix}`,
     type: 'application/pdf',
     arrayBuffer: async () => Promise.resolve(pdfBuffer),
   });
@@ -156,6 +175,7 @@ export const sealDocument = async ({
       event: 'App: Document Sealed',
       properties: {
         documentId: document.id,
+        isRejected,
       },
     });
   }
@@ -166,7 +186,7 @@ export const sealDocument = async ({
         id: document.id,
       },
       data: {
-        status: DocumentStatus.COMPLETED,
+        status: isRejected ? DocumentStatus.REJECTED : DocumentStatus.COMPLETED,
         completedAt: new Date(),
       },
     });
@@ -188,6 +208,7 @@ export const sealDocument = async ({
         user: null,
         data: {
           transactionId: nanoid(),
+          ...(isRejected ? { isRejected: true, rejectionReason } : {}),
         },
       }),
     });
@@ -209,7 +230,9 @@ export const sealDocument = async ({
   });
 
   await triggerWebhook({
-    event: WebhookTriggerEvents.DOCUMENT_COMPLETED,
+    event: isRejected
+      ? WebhookTriggerEvents.DOCUMENT_REJECTED
+      : WebhookTriggerEvents.DOCUMENT_COMPLETED,
     data: ZWebhookDocumentSchema.parse(mapDocumentToWebhookDocumentPayload(updatedDocument)),
     userId: document.userId,
     teamId: document.teamId ?? undefined,

packages/lib/server-only/document/search-documents-with-keyword.ts

@@ -34,6 +34,14 @@ export const searchDocumentsWithKeyword = async ({
           userId: userId,
           deletedAt: null,
         },
+        {
+          externalId: {
+            contains: query,
+            mode: 'insensitive',
+          },
+          userId: userId,
+          deletedAt: null,
+        },
         {
           recipients: {
             some: {
@@ -88,6 +96,23 @@ export const searchDocumentsWithKeyword = async ({
           },
           deletedAt: null,
         },
+        {
+          externalId: {
+            contains: query,
+            mode: 'insensitive',
+          },
+          teamId: {
+            not: null,
+          },
+          team: {
+            members: {
+              some: {
+                userId: userId,
+              },
+            },
+          },
+          deletedAt: null,
+        },
       ],
     },
     include: {

packages/lib/server-only/document/send-document.tsx

@@ -20,6 +20,7 @@ import {
 } from '../../types/webhook-payload';
 import { getFileServerSide } from '../../universal/upload/get-file.server';
 import { putPdfFileServerSide } from '../../universal/upload/put-file.server';
+import { isDocumentCompleted } from '../../utils/document';
 import { insertFormValuesInPdf } from '../pdf/insert-form-values-in-pdf';
 import { triggerWebhook } from '../webhooks/trigger/trigger-webhook';
 
@@ -74,7 +75,7 @@ export const sendDocument = async ({
     throw new Error('Document has no recipients');
   }
 
-  if (document.status === DocumentStatus.COMPLETED) {
+  if (isDocumentCompleted(document.status)) {
     throw new Error('Can not send completed document');
   }
 

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

@@ -1,5 +1,6 @@
+import { FieldType, RecipientRole, SigningStatus } from '@prisma/client';
+
 import { prisma } from '@documenso/prisma';
-import { FieldType, RecipientRole, SigningStatus } from '@documenso/prisma/client';
 
 export type GetFieldsForTokenOptions = {
   token: string;

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

@@ -201,7 +201,7 @@ export const signFieldWithToken = async ({
     throw new Error('Signature field must have a signature');
   }
 
-  if (isSignatureField && !documentMeta?.typedSignatureEnabled && typedSignature) {
+  if (isSignatureField && documentMeta?.typedSignatureEnabled === false && typedSignature) {
     throw new Error('Typed signatures are not allowed. Please draw your signature');
   }
 

packages/lib/server-only/pdf/add-rejection-stamp-to-pdf.ts

@@ -0,0 +1,87 @@
+import fontkit from '@pdf-lib/fontkit';
+import type { PDFDocument } from 'pdf-lib';
+import { TextAlignment, rgb, setFontAndSize } from 'pdf-lib';
+
+import { NEXT_PUBLIC_WEBAPP_URL } from '../../constants/app';
+
+/**
+ * Adds a rejection stamp to each page of a PDF document.
+ * The stamp is placed in the center of the page.
+ */
+export async function addRejectionStampToPdf(
+  pdfDoc: PDFDocument,
+  reason: string,
+): Promise<PDFDocument> {
+  const pages = pdfDoc.getPages();
+  pdfDoc.registerFontkit(fontkit);
+
+  const fontBytes = await fetch(`${NEXT_PUBLIC_WEBAPP_URL()}/fonts/noto-sans.ttf`).then(
+    async (res) => res.arrayBuffer(),
+  );
+
+  const font = await pdfDoc.embedFont(fontBytes, {
+    customName: 'Noto',
+  });
+
+  const form = pdfDoc.getForm();
+
+  for (let i = 0; i < pages.length; i++) {
+    const page = pages[i];
+    const { width, height } = page.getSize();
+
+    // Draw the "REJECTED" text
+    const rejectedTitleText = 'DOCUMENT REJECTED';
+    const rejectedTitleFontSize = 36;
+    const rejectedTitleTextField = form.createTextField(`internal-document-rejected-title-${i}`);
+
+    if (!rejectedTitleTextField.acroField.getDefaultAppearance()) {
+      rejectedTitleTextField.acroField.setDefaultAppearance(
+        setFontAndSize('Noto', rejectedTitleFontSize).toString(),
+      );
+    }
+
+    rejectedTitleTextField.updateAppearances(font);
+
+    rejectedTitleTextField.setFontSize(rejectedTitleFontSize);
+    rejectedTitleTextField.setText(rejectedTitleText);
+    rejectedTitleTextField.setAlignment(TextAlignment.Center);
+
+    const rejectedTitleTextWidth =
+      font.widthOfTextAtSize(rejectedTitleText, rejectedTitleFontSize) * 1.2;
+    const rejectedTitleTextHeight = font.heightAtSize(rejectedTitleFontSize);
+
+    // Calculate the center position of the page
+    const centerX = width / 2;
+    const centerY = height / 2;
+
+    // Position the title text at the center of the page
+    const rejectedTitleTextX = centerX - rejectedTitleTextWidth / 2;
+    const rejectedTitleTextY = centerY - rejectedTitleTextHeight / 2;
+
+    // Add padding for the rectangle
+    const padding = 20;
+
+    // Draw the stamp background
+    page.drawRectangle({
+      x: rejectedTitleTextX - padding / 2,
+      y: rejectedTitleTextY - padding / 2,
+      width: rejectedTitleTextWidth + padding,
+      height: rejectedTitleTextHeight + padding,
+      borderColor: rgb(220 / 255, 38 / 255, 38 / 255),
+      borderWidth: 4,
+    });
+
+    rejectedTitleTextField.addToPage(page, {
+      x: rejectedTitleTextX,
+      y: rejectedTitleTextY,
+      width: rejectedTitleTextWidth,
+      height: rejectedTitleTextHeight,
+      textColor: rgb(220 / 255, 38 / 255, 38 / 255),
+      backgroundColor: undefined,
+      borderWidth: 0,
+      borderColor: undefined,
+    });
+  }
+
+  return pdfDoc;
+}

packages/lib/server-only/public-api/get-all-team-tokens.ts

@@ -1,42 +0,0 @@
-import { TeamMemberRole } from '@prisma/client';
-
-import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
-import { prisma } from '@documenso/prisma';
-
-export type GetUserTokensOptions = {
-  userId: number;
-  teamId: number;
-};
-
-export type GetTeamTokensResponse = Awaited<ReturnType<typeof getTeamTokens>>;
-
-export const getTeamTokens = async ({ userId, teamId }: GetUserTokensOptions) => {
-  const teamMember = await prisma.teamMember.findFirst({
-    where: {
-      userId,
-      teamId,
-    },
-  });
-
-  if (teamMember?.role !== TeamMemberRole.ADMIN) {
-    throw new AppError(AppErrorCode.UNAUTHORIZED, {
-      message: 'You do not have the required permissions to view this page.',
-    });
-  }
-
-  return await prisma.apiToken.findMany({
-    where: {
-      teamId,
-    },
-    select: {
-      id: true,
-      name: true,
-      algorithm: true,
-      createdAt: true,
-      expires: true,
-    },
-    orderBy: {
-      createdAt: 'desc',
-    },
-  });
-};

packages/lib/server-only/public-api/get-all-user-tokens.ts

@@ -1,24 +0,0 @@
-import { prisma } from '@documenso/prisma';
-
-export type GetUserTokensOptions = {
-  userId: number;
-};
-
-export const getUserTokens = async ({ userId }: GetUserTokensOptions) => {
-  return await prisma.apiToken.findMany({
-    where: {
-      userId,
-      teamId: null,
-    },
-    select: {
-      id: true,
-      name: true,
-      algorithm: true,
-      createdAt: true,
-      expires: true,
-    },
-    orderBy: {
-      createdAt: 'desc',
-    },
-  });
-};

packages/lib/server-only/public-api/get-api-tokens.ts

@@ -0,0 +1,40 @@
+import { TeamMemberRole } from '@prisma/client';
+
+import { prisma } from '@documenso/prisma';
+
+export type GetApiTokensOptions = {
+  userId: number;
+  teamId?: number;
+};
+
+export const getApiTokens = async ({ userId, teamId }: GetApiTokensOptions) => {
+  return await prisma.apiToken.findMany({
+    where: {
+      ...(teamId
+        ? {
+            team: {
+              id: teamId,
+              members: {
+                some: {
+                  userId,
+                  role: TeamMemberRole.ADMIN,
+                },
+              },
+            },
+          }
+        : {
+            userId,
+            teamId: null,
+          }),
+    },
+    select: {
+      id: true,
+      name: true,
+      createdAt: true,
+      expires: true,
+    },
+    orderBy: {
+      createdAt: 'desc',
+    },
+  });
+};

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

@@ -1,5 +1,6 @@
+import { FieldType } from '@prisma/client';
+
 import { prisma } from '@documenso/prisma';
-import { FieldType } from '@documenso/prisma/client';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
 

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

@@ -205,7 +205,7 @@ export const createTeamFromPendingTeam = async ({
   pendingTeamId,
   subscription,
 }: CreateTeamFromPendingTeamOptions) => {
-  return await prisma.$transaction(async (tx) => {
+  const createdTeam = await prisma.$transaction(async (tx) => {
     const pendingTeam = await tx.teamPending.findUniqueOrThrow({
       where: {
         id: pendingTeamId,
@@ -249,19 +249,21 @@ export const createTeamFromPendingTeam = async ({
       mapStripeSubscriptionToPrismaUpsertAction(subscription, undefined, team.id),
     );
 
-    // Attach the team ID to the subscription metadata for sanity reasons.
-    await stripe.subscriptions
-      .update(subscription.id, {
-        metadata: {
-          teamId: team.id.toString(),
-        },
-      })
-      .catch((e) => {
-        console.error(e);
-        // Non-critical error, but we want to log it so we can rectify it.
-        // Todo: Teams - Alert us.
-      });
-
     return team;
   });
+
+  // Attach the team ID to the subscription metadata for sanity reasons.
+  await stripe.subscriptions
+    .update(subscription.id, {
+      metadata: {
+        teamId: createdTeam.id.toString(),
+      },
+    })
+    .catch((e) => {
+      console.error(e);
+      // Non-critical error, but we want to log it so we can rectify it.
+      // Todo: Teams - Alert us.
+    });
+
+  return createdTeam;
 };

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

@@ -1,73 +0,0 @@
-import type { DocumentVisibility } from '@prisma/client';
-import { TeamMemberRole } from '@prisma/client';
-import type { z } from 'zod';
-
-import { prisma } from '@documenso/prisma';
-import { TeamGlobalSettingsSchema } from '@documenso/prisma/generated/zod/modelSchema/TeamGlobalSettingsSchema';
-
-import type { SupportedLanguageCodes } from '../../constants/i18n';
-
-export type UpdateTeamDocumentSettingsOptions = {
-  userId: number;
-  teamId: number;
-
-  settings: {
-    documentVisibility: DocumentVisibility;
-    documentLanguage: SupportedLanguageCodes;
-    includeSenderDetails: boolean;
-    typedSignatureEnabled: boolean;
-    includeSigningCertificate: boolean;
-  };
-};
-
-export const ZUpdateTeamDocumentSettingsResponseSchema = TeamGlobalSettingsSchema;
-
-export type TUpdateTeamDocumentSettingsResponse = z.infer<
-  typeof ZUpdateTeamDocumentSettingsResponseSchema
->;
-
-export const updateTeamDocumentSettings = async ({
-  userId,
-  teamId,
-  settings,
-}: UpdateTeamDocumentSettingsOptions): Promise<TUpdateTeamDocumentSettingsResponse> => {
-  const {
-    documentVisibility,
-    documentLanguage,
-    includeSenderDetails,
-    includeSigningCertificate,
-    typedSignatureEnabled,
-  } = settings;
-
-  const member = await prisma.teamMember.findFirst({
-    where: {
-      userId,
-      teamId,
-    },
-  });
-
-  if (!member || member.role !== TeamMemberRole.ADMIN) {
-    throw new Error('You do not have permission to update this team.');
-  }
-
-  return await prisma.teamGlobalSettings.upsert({
-    where: {
-      teamId,
-    },
-    create: {
-      teamId,
-      documentVisibility,
-      documentLanguage,
-      includeSenderDetails,
-      typedSignatureEnabled,
-      includeSigningCertificate,
-    },
-    update: {
-      documentVisibility,
-      documentLanguage,
-      includeSenderDetails,
-      typedSignatureEnabled,
-      includeSigningCertificate,
-    },
-  });
-};

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

@@ -37,6 +37,7 @@ import {
   mapDocumentToWebhookDocumentPayload,
 } from '../../types/webhook-payload';
 import type { ApiRequestMetadata } from '../../universal/extract-request-metadata';
+import { isRequiredField } from '../../utils/advanced-fields-helpers';
 import type { CreateDocumentAuditLogDataResponse } from '../../utils/document-audit-logs';
 import { createDocumentAuditLogData } from '../../utils/document-audit-logs';
 import {
@@ -176,20 +177,28 @@ export const createDocumentFromDirectTemplate = async ({
   const metaSigningOrder = template.templateMeta?.signingOrder || DocumentSigningOrder.PARALLEL;
 
   // Associate, validate and map to a query every direct template recipient field with the provided fields.
+  // Only process fields that are either required or have been signed by the user
+  const fieldsToProcess = directTemplateRecipient.fields.filter((templateField) => {
+    const signedFieldValue = signedFieldValues.find((value) => value.fieldId === templateField.id);
+
+    // Include if it's required or has a signed value
+    return isRequiredField(templateField) || signedFieldValue !== undefined;
+  });
+
   const createDirectRecipientFieldArgs = await Promise.all(
-    directTemplateRecipient.fields.map(async (templateField) => {
+    fieldsToProcess.map(async (templateField) => {
       const signedFieldValue = signedFieldValues.find(
         (value) => value.fieldId === templateField.id,
       );
 
-      if (!signedFieldValue) {
+      if (isRequiredField(templateField) && !signedFieldValue) {
         throw new AppError(AppErrorCode.INVALID_BODY, {
           message: 'Invalid, missing or changed fields',
         });
       }
 
       if (templateField.type === FieldType.NAME && directRecipientName === undefined) {
-        directRecipientName === signedFieldValue.value;
+        directRecipientName === signedFieldValue?.value;
       }
 
       const derivedRecipientActionAuth = await validateFieldAuth({
@@ -200,9 +209,18 @@ export const createDocumentFromDirectTemplate = async ({
         },
         field: templateField,
         userId: user?.id,
-        authOptions: signedFieldValue.authOptions,
+        authOptions: signedFieldValue?.authOptions,
       });
 
+      if (!signedFieldValue) {
+        return {
+          templateField,
+          customText: '',
+          derivedRecipientActionAuth,
+          signature: null,
+        };
+      }
+
       const { value, isBase64 } = signedFieldValue;
 
       const isSignatureField =
@@ -306,6 +324,9 @@ export const createDocumentFromDirectTemplate = async ({
             language: metaLanguage,
             signingOrder: metaSigningOrder,
             distributionMethod: template.templateMeta?.distributionMethod,
+            typedSignatureEnabled: template.templateMeta?.typedSignatureEnabled,
+            uploadSignatureEnabled: template.templateMeta?.uploadSignatureEnabled,
+            drawSignatureEnabled: template.templateMeta?.drawSignatureEnabled,
           },
         },
       },
@@ -380,7 +401,7 @@ export const createDocumentFromDirectTemplate = async ({
               positionY: templateField.positionY,
               width: templateField.width,
               height: templateField.height,
-              customText,
+              customText: customText ?? '',
               inserted: true,
               fieldMeta: templateField.fieldMeta || Prisma.JsonNull,
             })),

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

@@ -96,6 +96,9 @@ export const createDocumentFromTemplateLegacy = async ({
           signingOrder: template.templateMeta?.signingOrder ?? undefined,
           language:
             template.templateMeta?.language || template.team?.teamGlobalSettings?.documentLanguage,
+          typedSignatureEnabled: template.templateMeta?.typedSignatureEnabled,
+          uploadSignatureEnabled: template.templateMeta?.uploadSignatureEnabled,
+          drawSignatureEnabled: template.templateMeta?.drawSignatureEnabled,
         },
       },
     },

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

@@ -9,6 +9,7 @@ import {
   SigningStatus,
   WebhookTriggerEvents,
 } from '@prisma/client';
+import { match } from 'ts-pattern';
 
 import { nanoid } from '@documenso/lib/universal/id';
 import { prisma } from '@documenso/prisma';
@@ -18,7 +19,20 @@ import { AppError, AppErrorCode } from '../../errors/app-error';
 import { DOCUMENT_AUDIT_LOG_TYPE } from '../../types/document-audit-logs';
 import { ZRecipientAuthOptionsSchema } from '../../types/document-auth';
 import type { TDocumentEmailSettings } from '../../types/document-email';
-import { ZFieldMetaSchema } from '../../types/field-meta';
+import type {
+  TCheckboxFieldMeta,
+  TDropdownFieldMeta,
+  TFieldMetaPrefillFieldsSchema,
+  TNumberFieldMeta,
+  TRadioFieldMeta,
+  TTextFieldMeta,
+} from '../../types/field-meta';
+import {
+  ZCheckboxFieldMeta,
+  ZDropdownFieldMeta,
+  ZFieldMetaSchema,
+  ZRadioFieldMeta,
+} from '../../types/field-meta';
 import {
   ZWebhookDocumentSchema,
   mapDocumentToWebhookDocumentPayload,
@@ -51,6 +65,7 @@ export type CreateDocumentFromTemplateOptions = {
     email: string;
     signingOrder?: number | null;
   }[];
+  prefillFields?: TFieldMetaPrefillFieldsSchema[];
   customDocumentDataId?: string;
 
   /**
@@ -67,12 +82,183 @@ export type CreateDocumentFromTemplateOptions = {
     signingOrder?: DocumentSigningOrder;
     language?: SupportedLanguageCodes;
     distributionMethod?: DocumentDistributionMethod;
-    typedSignatureEnabled?: boolean;
     emailSettings?: TDocumentEmailSettings;
+    typedSignatureEnabled?: boolean;
+    uploadSignatureEnabled?: boolean;
+    drawSignatureEnabled?: boolean;
   };
   requestMetadata: ApiRequestMetadata;
 };
 
+const getUpdatedFieldMeta = (field: Field, prefillField?: TFieldMetaPrefillFieldsSchema) => {
+  if (!prefillField) {
+    return field.fieldMeta;
+  }
+
+  const advancedField = ['NUMBER', 'RADIO', 'CHECKBOX', 'DROPDOWN', 'TEXT'].includes(field.type);
+
+  if (!advancedField) {
+    throw new AppError(AppErrorCode.INVALID_BODY, {
+      message: `Field ${field.id} is not an advanced field and cannot have field meta information. Allowed types: NUMBER, RADIO, CHECKBOX, DROPDOWN, TEXT.`,
+    });
+  }
+
+  // We've already validated that the field types match at a higher level
+  // Start with the existing field meta or an empty object
+  const existingMeta = field.fieldMeta || {};
+
+  // Apply type-specific updates based on the prefill field type using ts-pattern
+  return match(prefillField)
+    .with({ type: 'text' }, (field) => {
+      if (typeof field.value !== 'string') {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Invalid value for TEXT field ${field.id}: expected string, got ${typeof field.value}`,
+        });
+      }
+
+      const meta: TTextFieldMeta = {
+        ...existingMeta,
+        type: 'text',
+        label: field.label,
+        placeholder: field.placeholder,
+        text: field.value,
+      };
+
+      return meta;
+    })
+    .with({ type: 'number' }, (field) => {
+      if (typeof field.value !== 'string') {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Invalid value for NUMBER field ${field.id}: expected string, got ${typeof field.value}`,
+        });
+      }
+
+      const meta: TNumberFieldMeta = {
+        ...existingMeta,
+        type: 'number',
+        label: field.label,
+        placeholder: field.placeholder,
+        value: field.value,
+      };
+
+      return meta;
+    })
+    .with({ type: 'radio' }, (field) => {
+      if (typeof field.value !== 'string') {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Invalid value for RADIO field ${field.id}: expected string, got ${typeof field.value}`,
+        });
+      }
+
+      const result = ZRadioFieldMeta.safeParse(existingMeta);
+
+      if (!result.success) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Invalid field meta for RADIO field ${field.id}`,
+        });
+      }
+
+      const radioMeta = result.data;
+
+      // Validate that the value exists in the options
+      const valueExists = radioMeta.values?.some((option) => option.value === field.value);
+
+      if (!valueExists) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Value "${field.value}" not found in options for RADIO field ${field.id}`,
+        });
+      }
+
+      const newValues = radioMeta.values?.map((option) => ({
+        ...option,
+        checked: option.value === field.value,
+      }));
+
+      const meta: TRadioFieldMeta = {
+        ...existingMeta,
+        type: 'radio',
+        label: field.label,
+        values: newValues,
+      };
+
+      return meta;
+    })
+    .with({ type: 'checkbox' }, (field) => {
+      const result = ZCheckboxFieldMeta.safeParse(existingMeta);
+
+      if (!result.success) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Invalid field meta for CHECKBOX field ${field.id}`,
+        });
+      }
+
+      const checkboxMeta = result.data;
+
+      if (!field.value) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Value is required for CHECKBOX field ${field.id}`,
+        });
+      }
+
+      const fieldValue = field.value;
+
+      // Validate that all values exist in the options
+      for (const value of fieldValue) {
+        const valueExists = checkboxMeta.values?.some((option) => option.value === value);
+
+        if (!valueExists) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: `Value "${value}" not found in options for CHECKBOX field ${field.id}`,
+          });
+        }
+      }
+
+      const newValues = checkboxMeta.values?.map((option) => ({
+        ...option,
+        checked: fieldValue.includes(option.value),
+      }));
+
+      const meta: TCheckboxFieldMeta = {
+        ...existingMeta,
+        type: 'checkbox',
+        label: field.label,
+        values: newValues,
+      };
+
+      return meta;
+    })
+    .with({ type: 'dropdown' }, (field) => {
+      const result = ZDropdownFieldMeta.safeParse(existingMeta);
+
+      if (!result.success) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Invalid field meta for DROPDOWN field ${field.id}`,
+        });
+      }
+
+      const dropdownMeta = result.data;
+
+      // Validate that the value exists in the options if values are defined
+      const valueExists = dropdownMeta.values?.some((option) => option.value === field.value);
+
+      if (!valueExists) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `Value "${field.value}" not found in options for DROPDOWN field ${field.id}`,
+        });
+      }
+
+      const meta: TDropdownFieldMeta = {
+        ...existingMeta,
+        type: 'dropdown',
+        label: field.label,
+        defaultValue: field.value,
+      };
+
+      return meta;
+    })
+    .otherwise(() => field.fieldMeta);
+};
+
 export const createDocumentFromTemplate = async ({
   templateId,
   externalId,
@@ -82,6 +268,7 @@ export const createDocumentFromTemplate = async ({
   customDocumentDataId,
   override,
   requestMetadata,
+  prefillFields,
 }: CreateDocumentFromTemplateOptions) => {
   const template = await prisma.template.findUnique({
     where: {
@@ -219,6 +406,10 @@ export const createDocumentFromTemplate = async ({
               template.team?.teamGlobalSettings?.documentLanguage,
             typedSignatureEnabled:
               override?.typedSignatureEnabled ?? template.templateMeta?.typedSignatureEnabled,
+            uploadSignatureEnabled:
+              override?.uploadSignatureEnabled ?? template.templateMeta?.uploadSignatureEnabled,
+            drawSignatureEnabled:
+              override?.drawSignatureEnabled ?? template.templateMeta?.drawSignatureEnabled,
           },
         },
         recipients: {
@@ -259,6 +450,47 @@ export const createDocumentFromTemplate = async ({
 
     let fieldsToCreate: Omit<Field, 'id' | 'secondaryId' | 'templateId'>[] = [];
 
+    // Get all template field IDs first so we can validate later
+    const allTemplateFieldIds = finalRecipients.flatMap((recipient) =>
+      recipient.fields.map((field) => field.id),
+    );
+
+    if (prefillFields?.length) {
+      // Validate that all prefill field IDs exist in the template
+      const invalidFieldIds = prefillFields
+        .map((prefillField) => prefillField.id)
+        .filter((id) => !allTemplateFieldIds.includes(id));
+
+      if (invalidFieldIds.length > 0) {
+        throw new AppError(AppErrorCode.INVALID_BODY, {
+          message: `The following field IDs do not exist in the template: ${invalidFieldIds.join(', ')}`,
+        });
+      }
+
+      // Validate that all prefill fields have the correct type
+      for (const prefillField of prefillFields) {
+        const templateField = finalRecipients
+          .flatMap((recipient) => recipient.fields)
+          .find((field) => field.id === prefillField.id);
+
+        if (!templateField) {
+          // This should never happen due to the previous validation, but just in case
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: `Field with ID ${prefillField.id} not found in the template`,
+          });
+        }
+
+        const expectedType = templateField.type.toLowerCase();
+        const actualType = prefillField.type;
+
+        if (expectedType !== actualType) {
+          throw new AppError(AppErrorCode.INVALID_BODY, {
+            message: `Field type mismatch for field ${prefillField.id}: expected ${expectedType}, got ${actualType}`,
+          });
+        }
+      }
+    }
+
     Object.values(finalRecipients).forEach(({ email, fields }) => {
       const recipient = document.recipients.find((recipient) => recipient.email === email);
 
@@ -267,19 +499,25 @@ export const createDocumentFromTemplate = async ({
       }
 
       fieldsToCreate = fieldsToCreate.concat(
-        fields.map((field) => ({
-          documentId: document.id,
-          recipientId: recipient.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,
-        })),
+        fields.map((field) => {
+          const prefillField = prefillFields?.find((value) => value.id === field.id);
+          // Use type assertion to help TypeScript understand the structure
+          const updatedFieldMeta = getUpdatedFieldMeta(field, prefillField);
+
+          return {
+            documentId: document.id,
+            recipientId: recipient.id,
+            type: field.type,
+            page: field.page,
+            positionX: field.positionX,
+            positionY: field.positionY,
+            width: field.width,
+            height: field.height,
+            customText: '',
+            inserted: false,
+            fieldMeta: updatedFieldMeta,
+          };
+        }),
       );
     });
 

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

@@ -4,6 +4,8 @@ import { prisma } from '@documenso/prisma';
 import { TemplateSchema } from '@documenso/prisma/generated/zod/modelSchema//TemplateSchema';
 import type { TCreateTemplateMutationSchema } from '@documenso/trpc/server/template-router/schema';
 
+import { AppError, AppErrorCode } from '../../errors/app-error';
+
 export type CreateTemplateOptions = TCreateTemplateMutationSchema & {
   userId: number;
   teamId?: number;
@@ -19,8 +21,10 @@ export const createTemplate = async ({
   teamId,
   templateDocumentDataId,
 }: CreateTemplateOptions) => {
+  let team = null;
+
   if (teamId) {
-    await prisma.team.findFirstOrThrow({
+    team = await prisma.team.findFirst({
       where: {
         id: teamId,
         members: {
@@ -29,7 +33,14 @@ export const createTemplate = async ({
           },
         },
       },
+      include: {
+        teamGlobalSettings: true,
+      },
     });
+
+    if (!team) {
+      throw new AppError(AppErrorCode.NOT_FOUND);
+    }
   }
 
   return await prisma.template.create({
@@ -38,6 +49,14 @@ export const createTemplate = async ({
       userId,
       templateDocumentDataId,
       teamId,
+      templateMeta: {
+        create: {
+          language: team?.teamGlobalSettings?.documentLanguage,
+          typedSignatureEnabled: team?.teamGlobalSettings?.typedSignatureEnabled ?? true,
+          uploadSignatureEnabled: team?.teamGlobalSettings?.uploadSignatureEnabled ?? true,
+          drawSignatureEnabled: team?.teamGlobalSettings?.drawSignatureEnabled ?? true,
+        },
+      },
     },
   });
 };

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

@@ -0,0 +1,22 @@
+import type { User } from '@prisma/client';
+
+import { getStripeCustomerByUser } from '@documenso/ee/server-only/stripe/get-customer';
+import { getPortalSession } from '@documenso/ee/server-only/stripe/get-portal-session';
+import { IS_BILLING_ENABLED, NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+
+export type CreateBillingPortalOptions = {
+  user: Pick<User, 'id' | 'customerId' | 'email' | 'name'>;
+};
+
+export const createBillingPortal = async ({ user }: CreateBillingPortalOptions) => {
+  if (!IS_BILLING_ENABLED()) {
+    throw new Error('Billing is not enabled');
+  }
+
+  const { stripeCustomer } = await getStripeCustomerByUser(user);
+
+  return getPortalSession({
+    customerId: stripeCustomer.id,
+    returnUrl: `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing`,
+  });
+};

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

@@ -0,0 +1,39 @@
+import type { User } from '@prisma/client';
+
+import { getCheckoutSession } from '@documenso/ee/server-only/stripe/get-checkout-session';
+import { getStripeCustomerByUser } from '@documenso/ee/server-only/stripe/get-customer';
+import { getPortalSession } from '@documenso/ee/server-only/stripe/get-portal-session';
+import { NEXT_PUBLIC_WEBAPP_URL } from '@documenso/lib/constants/app';
+
+import { getSubscriptionsByUserId } from '../subscription/get-subscriptions-by-user-id';
+
+export type CreateCheckoutSession = {
+  user: Pick<User, 'id' | 'customerId' | 'email' | 'name'>;
+  priceId: string;
+};
+
+export const createCheckoutSession = async ({ user, priceId }: CreateCheckoutSession) => {
+  const { stripeCustomer } = await getStripeCustomerByUser(user);
+
+  const existingSubscriptions = await getSubscriptionsByUserId({ userId: user.id });
+
+  const foundSubscription = existingSubscriptions.find(
+    (subscription) =>
+      subscription.priceId === priceId &&
+      subscription.periodEnd &&
+      subscription.periodEnd >= new Date(),
+  );
+
+  if (foundSubscription) {
+    return getPortalSession({
+      customerId: stripeCustomer.id,
+      returnUrl: `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing`,
+    });
+  }
+
+  return getCheckoutSession({
+    customerId: stripeCustomer.id,
+    priceId,
+    returnUrl: `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing`,
+  });
+};

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

@@ -52,18 +52,18 @@ export const createUser = async ({ name, email, password, signature, url }: Crea
       data: {
         name,
         email: email.toLowerCase(),
-        password: hashedPassword, // Todo: Drop password.
+        password: hashedPassword, // Todo: (RR7) Drop password.
         signature,
         url,
       },
     });
 
-    // Todo: Migrate to use this after RR7.
+    // Todo: (RR7) Migrate to use this after RR7.
     // await tx.account.create({
     //   data: {
     //     userId: user.id,
-    //     type: 'emailPassword', // Todo
-    //     provider: 'DOCUMENSO', // Todo: Enums
+    //     type: 'emailPassword', // Todo: (RR7)
+    //     provider: 'DOCUMENSO', // Todo: (RR7) Enums
     //     providerAccountId: user.id.toString(),
     //     password: hashedPassword,
     //   },
@@ -73,7 +73,7 @@ export const createUser = async ({ name, email, password, signature, url }: Crea
   });
 
   await onCreateUserHook(user).catch((err) => {
-    // Todo: Add logging.
+    // Todo: (RR7) Add logging.
     console.error(err);
   });
 

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

@@ -29,7 +29,7 @@ export const deleteUser = async ({ id }: DeleteUserOptions) => {
     where: {
       userId: user.id,
       status: {
-        in: [DocumentStatus.PENDING, DocumentStatus.COMPLETED],
+        in: [DocumentStatus.PENDING, DocumentStatus.REJECTED, DocumentStatus.COMPLETED],
       },
     },
     data: {

packages/lib/server-only/webhooks/trigger/handler.ts

@@ -21,14 +21,16 @@ export const handlerTriggerWebhooks = async (req: Request) => {
     return Response.json({ success: false, error: 'Missing signature' }, { status: 400 });
   }
 
-  const valid = verify(req.body, signature);
+  const body = await req.json();
+
+  const valid = verify(body, signature);
 
   if (!valid) {
     console.log('Invalid signature');
     return Response.json({ success: false, error: 'Invalid signature' }, { status: 400 });
   }
 
-  const result = ZTriggerWebhookBodySchema.safeParse(req.body);
+  const result = ZTriggerWebhookBodySchema.safeParse(body);
 
   if (!result.success) {
     console.log('Invalid request body');

packages/lib/server-only/webhooks/zapier/list-documents.ts

@@ -64,6 +64,8 @@ export const listDocumentsHandler = async (req: Request) => {
 
     return Response.json([]);
   } catch (err) {
+    console.error(err);
+
     return Response.json(
       {
         message: 'Internal Server Error',

packages/lib/server-only/webhooks/zapier/subscribe.ts

@@ -27,6 +27,8 @@ export const subscribeHandler = async (req: Request) => {
 
     return Response.json(createdWebhook);
   } catch (err) {
+    console.error(err);
+
     return Response.json(
       {
         message: 'Internal Server Error',

packages/lib/server-only/webhooks/zapier/unsubscribe.ts

@@ -24,6 +24,8 @@ export const unsubscribeHandler = async (req: Request) => {
 
     return Response.json(deletedWebhook);
   } catch (err) {
+    console.error(err);
+
     return Response.json(
       {
         message: 'Internal Server Error',