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 {
+    // First, check if the document exists directly before performing the multi-promise
+    const documentExists = await prisma.document.findFirst({
+      where: {
+        id: documentId,
+      },
+      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.document.findFirstOrThrow({
+
+      prisma.recipient.findFirstOrThrow({
+        where: {
+          id: recipientId,
+        },
+      }),
+    ]);
+
+    // Get the document without restricting to PENDING status
+    const document = await prisma.document.findFirstOrThrow({
       where: {
         id: documentId,
-        status: DocumentStatus.PENDING,
+        // 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,13 +86,7 @@ export const run = async ({
           },
         },
       },
-    }),
-    prisma.recipient.findFirstOrThrow({
-      where: {
-        id: recipientId,
-      },
-    }),
-  ]);
+    });
 
     const { documentMeta, team } = document;
 
@@ -209,4 +236,8 @@ export const run = async ({
         }),
       });
     });
+  } 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",

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)) {
-    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,
-          },
-        });
-      }),
-    );
-  }
+  const shouldSendEmail =
+    sendEmail || (isRecipientSigningRequestEmailEnabled && sendEmail === undefined);
 
   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, TeamMemberRole } from '@prisma/client';
+import { DocumentStatus, DocumentVisibility, 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;
   }