chore: fix build errors

docker/development/compose.yml

@@ -40,43 +40,6 @@ services:
     entrypoint: sh
     command: -c 'mkdir -p /data/documenso && minio server /data --console-address ":9001" --address ":9002"'
 
-  triggerdotdev:
-    image: ghcr.io/triggerdotdev/trigger.dev:latest
-    container_name: triggerdotdev
-    environment:
-      - LOGIN_ORIGIN=http://localhost:3030
-      - APP_ORIGIN=http://localhost:3030
-      - PORT=3030
-      - REMIX_APP_PORT=3030
-      - MAGIC_LINK_SECRET=secret
-      - SESSION_SECRET=secret
-      - ENCRYPTION_KEY=deadbeefcafefeed
-      - DATABASE_URL=postgresql://trigger:password@triggerdotdev_database:5432/trigger
-      - DIRECT_URL=postgresql://trigger:password@triggerdotdev_database:5432/trigger
-      - RUNTIME_PLATFORM=docker-compose
-    ports:
-      - 3030:3030
-    depends_on:
-      - triggerdotdev_database
-
-  triggerdotdev_database:
-    container_name: triggerdotdev_database
-    image: postgres:15
-    volumes:
-      - triggerdotdev_database:/var/lib/postgresql/data
-    healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U ${POSTGRES_USER}']
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    environment:
-      - POSTGRES_USER=trigger
-      - POSTGRES_PASSWORD=password
-      - POSTGRES_DB=trigger
-    ports:
-      - 54321:5432
-
 volumes:
   minio:
   documenso_database:
-  triggerdotdev_database:

package.json

@@ -28,7 +28,6 @@
     "with:env": "dotenv -e .env -e .env.local --",
     "reset:hard": "npm run clean && npm i && npm run prisma:generate",
     "precommit": "npm install && git add package.json package-lock.json",
-    "trigger:dev": "npm run with:env -- npx trigger-cli dev --handler-path=\"/api/jobs\"",
     "inngest:dev": "inngest dev -u http://localhost:3000/api/jobs",
     "make:version": "npm version --workspace @documenso/remix --include-workspace-root --no-git-tag-version -m \"v%s\"",
     "translate": "npm run translate:extract && npm run translate:compile",
@@ -44,7 +43,6 @@
     "@commitlint/cli": "^17.7.1",
     "@commitlint/config-conventional": "^17.7.0",
     "@lingui/cli": "^5.2.0",
-    "@trigger.dev/cli": "^2.3.18",
     "dotenv": "^16.3.1",
     "dotenv-cli": "^7.3.0",
     "eslint": "^8.40.0",
@@ -76,8 +74,5 @@
   },
   "overrides": {
     "zod": "3.24.1"
-  },
-  "trigger.dev": {
-    "endpointId": "documenso-app"
   }
 }

packages/lib/jobs/client/client.ts

@@ -1,13 +1,19 @@
 import { match } from 'ts-pattern';
 
 import { env } from '../../utils/env';
-import type { JobDefinition, TriggerJobOptions } from './_internal/job';
+import type {
+  JobDefinition,
+  JobRunIO,
+  SimpleTriggerJobOptions,
+  TriggerJobOptions,
+} from './_internal/job';
 import type { BaseJobProvider as JobClientProvider } from './base';
 import { InngestJobProvider } from './inngest';
 import { LocalJobProvider } from './local';
 
 export class JobClient<T extends ReadonlyArray<JobDefinition> = []> {
   private _provider: JobClientProvider;
+  private _jobDefinitions: Record<string, JobDefinition> = {};
 
   public constructor(definitions: T) {
     this._provider = match(env('NEXT_PRIVATE_JOBS_PROVIDER'))
@@ -16,10 +22,67 @@ export class JobClient<T extends ReadonlyArray<JobDefinition> = []> {
 
     definitions.forEach((definition) => {
       this._provider.defineJob(definition);
+      this._jobDefinitions[definition.id] = definition;
     });
   }
 
-  public async triggerJob(options: TriggerJobOptions<T>) {
+  /**
+   * Check if Inngest background job processing is available.
+   *
+   * For Inngest to be considered available:
+   * 1. NEXT_PRIVATE_JOBS_PROVIDER must be set to 'inngest'
+   * 2. Either INNGEST_EVENT_KEY or NEXT_PRIVATE_INNGEST_EVENT_KEY must be provided
+   *
+   * If Inngest is not available, jobs will be executed synchronously without background scheduling.
+   */
+  public isInngestAvailable(): boolean {
+    return (
+      env('NEXT_PRIVATE_JOBS_PROVIDER') === 'inngest' &&
+      Boolean(env('INNGEST_EVENT_KEY') || env('NEXT_PRIVATE_INNGEST_EVENT_KEY'))
+    );
+  }
+
+  public async triggerJob(options: TriggerJobOptions<T>): Promise<unknown> {
+    // When Inngest is not available, execute the job directly
+    if (!this.isInngestAvailable()) {
+      const eligibleJob = Object.values(this._jobDefinitions).find(
+        (job) => job.trigger.name === options.name,
+      );
+
+      if (eligibleJob && eligibleJob.handler) {
+        // Execute the job directly without scheduling
+        const payload = options.payload;
+        const io: JobRunIO = {
+          wait: async (_cacheKey: string, ms: number): Promise<void> => {
+            // Create a Promise that resolves after ms milliseconds
+            return new Promise<void>((resolve) => {
+              setTimeout(resolve, ms);
+            });
+          },
+          logger: console,
+          runTask: async <R>(cacheKey: string, callback: () => Promise<R>): Promise<R> => {
+            return await callback();
+          },
+          triggerJob: async (
+            _cacheKey: string,
+            jobOptions: SimpleTriggerJobOptions,
+          ): Promise<unknown> => {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return await this.triggerJob(jobOptions as TriggerJobOptions<T>);
+          },
+        };
+
+        try {
+          const result = await eligibleJob.handler({ payload, io });
+          return result;
+        } catch (error) {
+          console.error(`Direct job execution failed for ${options.name}:`, error);
+          throw error;
+        }
+      }
+    }
+
+    // Use background processing with Inngest if available
     return this._provider.triggerJob(options);
   }
 

packages/lib/jobs/definitions/emails/send-signing-email.handler.ts

@@ -32,16 +32,49 @@ export const run = async ({
 }) => {
   const { userId, documentId, recipientId, requestMetadata } = payload;
 
-  const [user, document, recipient] = await Promise.all([
+  try {
-    prisma.user.findFirstOrThrow({
+    // First, check if the document exists directly before performing the multi-promise
-      where: {
+    const documentExists = await prisma.document.findFirst({
-        id: userId,
-      },
-    }),
-    prisma.document.findFirstOrThrow({
       where: {
         id: documentId,
-        status: DocumentStatus.PENDING,
+      },
+      select: { id: true },
+    });
+
+    if (!documentExists) {
+      throw new Error(`No Document found with ID ${documentId}`);
+    }
+
+    // Add a small delay to allow any pending transactions to complete
+    await new Promise<void>((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, 100);
+    });
+
+    const [user, recipient] = await Promise.all([
+      prisma.user.findFirstOrThrow({
+        where: {
+          id: userId,
+        },
+      }),
+
+      prisma.recipient.findFirstOrThrow({
+        where: {
+          id: recipientId,
+        },
+      }),
+    ]);
+
+    // Get the document without restricting to PENDING status
+    const document = await prisma.document.findFirstOrThrow({
+      where: {
+        id: documentId,
+        // Don't restrict to PENDING status, as it might still be in DRAFT status
+        // if the transaction hasn't fully completed yet
+        status: {
+          in: [DocumentStatus.DRAFT, DocumentStatus.PENDING],
+        },
       },
       include: {
         documentMeta: true,
@@ -53,160 +86,158 @@ export const run = async ({
           },
         },
       },
-    }),
+    });
-    prisma.recipient.findFirstOrThrow({
-      where: {
-        id: recipientId,
-      },
-    }),
-  ]);
 
-  const { documentMeta, team } = document;
+    const { documentMeta, team } = document;
 
-  if (recipient.role === RecipientRole.CC) {
+    if (recipient.role === RecipientRole.CC) {
-    return;
+      return;
-  }
+    }
 
-  const isRecipientSigningRequestEmailEnabled = extractDerivedDocumentEmailSettings(
+    const isRecipientSigningRequestEmailEnabled = extractDerivedDocumentEmailSettings(
-    document.documentMeta,
+      document.documentMeta,
-  ).recipientSigningRequest;
+    ).recipientSigningRequest;
 
-  if (!isRecipientSigningRequestEmailEnabled) {
+    if (!isRecipientSigningRequestEmailEnabled) {
-    return;
+      return;
-  }
+    }
 
-  const customEmail = document?.documentMeta;
+    const customEmail = document?.documentMeta;
-  const isDirectTemplate = document.source === DocumentSource.TEMPLATE_DIRECT_LINK;
+    const isDirectTemplate = document.source === DocumentSource.TEMPLATE_DIRECT_LINK;
-  const isTeamDocument = document.teamId !== null;
+    const isTeamDocument = document.teamId !== null;
 
-  const recipientEmailType = RECIPIENT_ROLE_TO_EMAIL_TYPE[recipient.role];
+    const recipientEmailType = RECIPIENT_ROLE_TO_EMAIL_TYPE[recipient.role];
 
-  const { email, name } = recipient;
+    const { email, name } = recipient;
-  const selfSigner = email === user.email;
+    const selfSigner = email === user.email;
 
-  const i18n = await getI18nInstance(documentMeta?.language);
+    const i18n = await getI18nInstance(documentMeta?.language);
 
-  const recipientActionVerb = i18n
+    const recipientActionVerb = i18n
-    ._(RECIPIENT_ROLES_DESCRIPTION[recipient.role].actionVerb)
+      ._(RECIPIENT_ROLES_DESCRIPTION[recipient.role].actionVerb)
-    .toLowerCase();
+      .toLowerCase();
 
-  let emailMessage = customEmail?.message || '';
+    let emailMessage = customEmail?.message || '';
-  let emailSubject = i18n._(msg`Please ${recipientActionVerb} this document`);
+    let emailSubject = i18n._(msg`Please ${recipientActionVerb} this document`);
-
-  if (selfSigner) {
-    emailMessage = i18n._(
-      msg`You have initiated the document ${`"${document.title}"`} that requires you to ${recipientActionVerb} it.`,
-    );
-    emailSubject = i18n._(msg`Please ${recipientActionVerb} your document`);
-  }
-
-  if (isDirectTemplate) {
-    emailMessage = i18n._(
-      msg`A document was created by your direct template that requires you to ${recipientActionVerb} it.`,
-    );
-    emailSubject = i18n._(
-      msg`Please ${recipientActionVerb} this document created by your direct template`,
-    );
-  }
-
-  if (isTeamDocument && team) {
-    emailSubject = i18n._(msg`${team.name} invited you to ${recipientActionVerb} a document`);
-    emailMessage = customEmail?.message ?? '';
-
-    if (!emailMessage) {
-      const inviterName = user.name || '';
 
+    if (selfSigner) {
       emailMessage = i18n._(
-        team.teamGlobalSettings?.includeSenderDetails
+        msg`You have initiated the document ${`"${document.title}"`} that requires you to ${recipientActionVerb} it.`,
-          ? msg`${inviterName} on behalf of "${team.name}" has invited you to ${recipientActionVerb} the document "${document.title}".`
+      );
-          : msg`${team.name} has invited you to ${recipientActionVerb} the document "${document.title}".`,
+      emailSubject = i18n._(msg`Please ${recipientActionVerb} your document`);
+    }
+
+    if (isDirectTemplate) {
+      emailMessage = i18n._(
+        msg`A document was created by your direct template that requires you to ${recipientActionVerb} it.`,
+      );
+      emailSubject = i18n._(
+        msg`Please ${recipientActionVerb} this document created by your direct template`,
       );
     }
-  }
 
-  const customEmailTemplate = {
+    if (isTeamDocument && team) {
-    'signer.name': name,
+      emailSubject = i18n._(msg`${team.name} invited you to ${recipientActionVerb} a document`);
-    'signer.email': email,
+      emailMessage = customEmail?.message ?? '';
-    'document.name': document.title,
-  };
 
-  const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
+      if (!emailMessage) {
-  const signDocumentLink = `${NEXT_PUBLIC_WEBAPP_URL()}/sign/${recipient.token}`;
+        const inviterName = user.name || '';
 
-  const template = createElement(DocumentInviteEmailTemplate, {
+        emailMessage = i18n._(
-    documentName: document.title,
+          team.teamGlobalSettings?.includeSenderDetails
-    inviterName: user.name || undefined,
+            ? msg`${inviterName} on behalf of "${team.name}" has invited you to ${recipientActionVerb} the document "${document.title}".`
-    inviterEmail: isTeamDocument ? team?.teamEmail?.email || user.email : user.email,
+            : msg`${team.name} has invited you to ${recipientActionVerb} the document "${document.title}".`,
-    assetBaseUrl,
+        );
-    signDocumentLink,
+      }
-    customBody: renderCustomEmailTemplate(emailMessage, customEmailTemplate),
+    }
-    role: recipient.role,
-    selfSigner,
-    isTeamInvite: isTeamDocument,
-    teamName: team?.name,
-    teamEmail: team?.teamEmail?.email,
-    includeSenderDetails: team?.teamGlobalSettings?.includeSenderDetails,
-  });
 
-  await io.runTask('send-signing-email', async () => {
+    const customEmailTemplate = {
-    const branding = document.team?.teamGlobalSettings
+      'signer.name': name,
-      ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
+      'signer.email': email,
-      : undefined;
+      'document.name': document.title,
+    };
 
-    const [html, text] = await Promise.all([
+    const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
-      renderEmailWithI18N(template, { lang: documentMeta?.language, branding }),
+    const signDocumentLink = `${NEXT_PUBLIC_WEBAPP_URL()}/sign/${recipient.token}`;
-      renderEmailWithI18N(template, {
-        lang: documentMeta?.language,
-        branding,
-        plainText: true,
-      }),
-    ]);
 
-    await mailer.sendMail({
+    const template = createElement(DocumentInviteEmailTemplate, {
-      to: {
+      documentName: document.title,
-        name: recipient.name,
+      inviterName: user.name || undefined,
-        address: recipient.email,
+      inviterEmail: isTeamDocument ? team?.teamEmail?.email || user.email : user.email,
-      },
+      assetBaseUrl,
-      from: {
+      signDocumentLink,
-        name: FROM_NAME,
+      customBody: renderCustomEmailTemplate(emailMessage, customEmailTemplate),
-        address: FROM_ADDRESS,
+      role: recipient.role,
-      },
+      selfSigner,
-      subject: renderCustomEmailTemplate(
+      isTeamInvite: isTeamDocument,
-        documentMeta?.subject || emailSubject,
+      teamName: team?.name,
-        customEmailTemplate,
+      teamEmail: team?.teamEmail?.email,
-      ),
+      includeSenderDetails: team?.teamGlobalSettings?.includeSenderDetails,
-      html,
-      text,
     });
-  });
 
-  await io.runTask('update-recipient', async () => {
+    await io.runTask('send-signing-email', async () => {
-    await prisma.recipient.update({
+      const branding = document.team?.teamGlobalSettings
-      where: {
+        ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
-        id: recipient.id,
+        : undefined;
-      },
-      data: {
-        sendStatus: SendStatus.SENT,
-      },
-    });
-  });
 
-  await io.runTask('store-audit-log', async () => {
+      const [html, text] = await Promise.all([
-    await prisma.documentAuditLog.create({
+        renderEmailWithI18N(template, { lang: documentMeta?.language, branding }),
-      data: createDocumentAuditLogData({
+        renderEmailWithI18N(template, {
-        type: DOCUMENT_AUDIT_LOG_TYPE.EMAIL_SENT,
+          lang: documentMeta?.language,
-        documentId: document.id,
+          branding,
-        user,
+          plainText: true,
-        requestMetadata,
+        }),
-        data: {
+      ]);
-          emailType: recipientEmailType,
+
-          recipientId: recipient.id,
+      await mailer.sendMail({
-          recipientName: recipient.name,
+        to: {
-          recipientEmail: recipient.email,
+          name: recipient.name,
-          recipientRole: recipient.role,
+          address: recipient.email,
-          isResending: false,
         },
-      }),
+        from: {
+          name: FROM_NAME,
+          address: FROM_ADDRESS,
+        },
+        subject: renderCustomEmailTemplate(
+          documentMeta?.subject || emailSubject,
+          customEmailTemplate,
+        ),
+        html,
+        text,
+      });
     });
-  });
+
+    await io.runTask('update-recipient', async () => {
+      await prisma.recipient.update({
+        where: {
+          id: recipient.id,
+        },
+        data: {
+          sendStatus: SendStatus.SENT,
+        },
+      });
+    });
+
+    await io.runTask('store-audit-log', async () => {
+      await prisma.documentAuditLog.create({
+        data: createDocumentAuditLogData({
+          type: DOCUMENT_AUDIT_LOG_TYPE.EMAIL_SENT,
+          documentId: document.id,
+          user,
+          requestMetadata,
+          data: {
+            emailType: recipientEmailType,
+            recipientId: recipient.id,
+            recipientName: recipient.name,
+            recipientEmail: recipient.email,
+            recipientRole: recipient.role,
+            isResending: false,
+          },
+        }),
+      });
+    });
+  } catch (error) {
+    console.error(`Job failed with error:`, error);
+    throw error;
+  }
 };

packages/lib/package.json

@@ -28,7 +28,6 @@
     "@lingui/core": "^5.2.0",
     "@lingui/macro": "^5.2.0",
     "@lingui/react": "^5.2.0",
-    "jose": "^6.0.0",
     "@noble/ciphers": "0.4.0",
     "@noble/hashes": "1.3.2",
     "@node-rs/bcrypt": "^1.10.0",
@@ -38,6 +37,7 @@
     "@vvo/tzdb": "^6.117.0",
     "csv-parse": "^5.6.0",
     "inngest": "^3.19.13",
+    "jose": "^6.0.0",
     "kysely": "0.26.3",
     "luxon": "^3.4.0",
     "micro": "^10.0.1",
@@ -47,6 +47,7 @@
     "pg": "^8.11.3",
     "playwright": "1.43.0",
     "posthog-js": "^1.224.0",
+    "posthog-node": "^4.17.1",
     "react": "^18",
     "remeda": "^2.17.3",
     "sharp": "0.32.6",
@@ -59,4 +60,4 @@
     "@types/luxon": "^3.3.1",
     "@types/pg": "^8.11.4"
   }
-}
+}

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

@@ -133,31 +133,6 @@ export const sendDocument = async ({
     Object.assign(document, result);
   }
 
-  // Commented out server side checks for minimum 1 signature per signer now since we need to
-  // decide if we want to enforce this for API & templates.
-  // const fields = await getFieldsForDocument({
-  //   documentId: documentId,
-  //   userId: userId,
-  // });
-
-  // const fieldsWithSignerEmail = fields.map((field) => ({
-  //   ...field,
-  //   signerEmail:
-  //     document.Recipient.find((recipient) => recipient.id === field.recipientId)?.email ?? '',
-  // }));
-
-  // const everySignerHasSignature = document?.Recipient.every(
-  //   (recipient) =>
-  //     recipient.role !== RecipientRole.SIGNER ||
-  //     fieldsWithSignerEmail.some(
-  //       (field) => field.type === 'SIGNATURE' && field.signerEmail === recipient.email,
-  //     ),
-  // );
-
-  // if (!everySignerHasSignature) {
-  //   throw new Error('Some signers have not been assigned a signature field.');
-  // }
-
   const isRecipientSigningRequestEmailEnabled = extractDerivedDocumentEmailSettings(
     document.documentMeta,
   ).recipientSigningRequest;
@@ -165,52 +140,14 @@ export const sendDocument = async ({
   // Only send email if one of the following is true:
   // - It is explicitly set
   // - The email is enabled for signing requests AND sendEmail is undefined
-  if (sendEmail || (isRecipientSigningRequestEmailEnabled && sendEmail === undefined)) {
+  const shouldSendEmail =
-    await Promise.all(
+    sendEmail || (isRecipientSigningRequestEmailEnabled && sendEmail === undefined);
-      recipientsToNotify.map(async (recipient) => {
-        if (recipient.sendStatus === SendStatus.SENT || recipient.role === RecipientRole.CC) {
-          return;
-        }
-
-        await jobs.triggerJob({
-          name: 'send.signing.requested.email',
-          payload: {
-            userId,
-            documentId,
-            recipientId: recipient.id,
-            requestMetadata: requestMetadata?.requestMetadata,
-          },
-        });
-      }),
-    );
-  }
 
   const allRecipientsHaveNoActionToTake = document.recipients.every(
     (recipient) =>
       recipient.role === RecipientRole.CC || recipient.signingStatus === SigningStatus.SIGNED,
   );
 
-  if (allRecipientsHaveNoActionToTake) {
-    await jobs.triggerJob({
-      name: 'internal.seal-document',
-      payload: {
-        documentId,
-        requestMetadata: requestMetadata?.requestMetadata,
-      },
-    });
-
-    // Keep the return type the same for the `sendDocument` method
-    return await prisma.document.findFirstOrThrow({
-      where: {
-        id: documentId,
-      },
-      include: {
-        documentMeta: true,
-        recipients: true,
-      },
-    });
-  }
-
   const updatedDocument = await prisma.$transaction(async (tx) => {
     if (document.status === DocumentStatus.DRAFT) {
       await tx.documentAuditLog.create({
@@ -244,5 +181,47 @@ export const sendDocument = async ({
     teamId,
   });
 
+  // Now that the transaction is complete and document status is updated, trigger email jobs
+  if (shouldSendEmail) {
+    await Promise.all(
+      recipientsToNotify.map(async (recipient) => {
+        if (recipient.sendStatus === SendStatus.SENT || recipient.role === RecipientRole.CC) {
+          return;
+        }
+
+        await jobs.triggerJob({
+          name: 'send.signing.requested.email',
+          payload: {
+            userId,
+            documentId,
+            recipientId: recipient.id,
+            requestMetadata: requestMetadata?.requestMetadata,
+          },
+        });
+      }),
+    );
+  }
+
+  if (allRecipientsHaveNoActionToTake) {
+    await jobs.triggerJob({
+      name: 'internal.seal-document',
+      payload: {
+        documentId,
+        requestMetadata: requestMetadata?.requestMetadata,
+      },
+    });
+
+    // Keep the return type the same for the `sendDocument` method
+    return await prisma.document.findFirstOrThrow({
+      where: {
+        id: documentId,
+      },
+      include: {
+        documentMeta: true,
+        recipients: true,
+      },
+    });
+  }
+
   return updatedDocument;
 };

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

@@ -1,5 +1,4 @@
-import { DocumentVisibility } from '@prisma/client';
+import { DocumentStatus, DocumentVisibility, TeamMemberRole } from '@prisma/client';
-import { DocumentStatus, TeamMemberRole } from '@prisma/client';
 import { match } from 'ts-pattern';
 
 import { isUserEnterprise } from '@documenso/ee/server-only/util/is-document-enterprise';
@@ -119,7 +118,6 @@ export const updateDocument = async ({
 
   // If no data just return the document since this function is normally chained after a meta update.
   if (!data || Object.values(data).length === 0) {
-    console.log('no data');
     return document;
   }