Merge branch 'main' into feat/template-document-name-options

packages/trpc/server/field-router/router.ts

@@ -1,3 +1,4 @@
+import { AppError } from '@documenso/lib/errors/app-error';
 import { createEnvelopeFields } from '@documenso/lib/server-only/field/create-envelope-fields';
 import { deleteDocumentField } from '@documenso/lib/server-only/field/delete-document-field';
 import { deleteTemplateField } from '@documenso/lib/server-only/field/delete-template-field';
@@ -613,23 +614,37 @@ export const fieldRouter = router({
    * @private
    */
   signFieldWithToken: procedure.input(ZSignFieldWithTokenMutationSchema).mutation(async ({ input, ctx }) => {
-    const { token, fieldId, value, isBase64, authOptions } = input;
+    try {
+      const { token, fieldId, value, isBase64, authOptions } = input;
 
-    ctx.logger.info({
+      ctx.logger.info({
-      input: {
+        input: {
+          fieldId,
+        },
+      });
+
+      return await signFieldWithToken({
+        token,
         fieldId,
-      },
+        value: value ?? '',
-    });
+        isBase64,
+        userId: ctx.user?.id,
+        authOptions,
+        requestMetadata: ctx.metadata.requestMetadata,
+      });
+    } catch (err) {
+      // Log the error for debugging purposes.
+      ctx.logger.error({
+        message: 'Error signing field with token',
+        error: err instanceof AppError ? `[${err.code}]: ${err.message}` : String(err),
+      });
 
-    return await signFieldWithToken({
+      // Raw console.log incase we're somehow deailing with a funky error object that doesn't serialize well.
-      token,
+      console.log('Error signing field with token', err);
-      fieldId,
+
-      value: value ?? '',
+      // Rethrow the error so that the client receives the appropriate error response.
-      isBase64,
+      throw err;
-      userId: ctx.user?.id,
+    }
-      authOptions,
-      requestMetadata: ctx.metadata.requestMetadata,
-    });
   }),
 
   /**
@@ -638,18 +653,31 @@ export const fieldRouter = router({
   removeSignedFieldWithToken: procedure
     .input(ZRemovedSignedFieldWithTokenMutationSchema)
     .mutation(async ({ input, ctx }) => {
-      const { token, fieldId } = input;
+      try {
+        const { token, fieldId } = input;
 
-      ctx.logger.info({
+        ctx.logger.info({
-        input: {
+          input: {
+            fieldId,
+          },
+        });
+
+        return await removeSignedFieldWithToken({
+          token,
           fieldId,
-        },
+          requestMetadata: ctx.metadata.requestMetadata,
-      });
+        });
+      } catch (err) {
+        // Log the error for debugging purposes.
+        ctx.logger.error({
+          message: 'Error removing signed field with token',
+          error: err instanceof AppError ? `[${err.code}]: ${err.message}` : String(err),
+        });
 
-      return await removeSignedFieldWithToken({
+        console.log('Error removing signed field with token', err);
-        token,
+
-        fieldId,
+        // Rethrow the error so that the client receives the appropriate error response.
-        requestMetadata: ctx.metadata.requestMetadata,
+        throw err;
-      });
+      }
     }),
 });

packages/trpc/server/recipient-router/router.ts

@@ -1,4 +1,5 @@
 import { prepareCscRecipientSigning } from '@documenso/ee/server-only/signing/csc/prepare-recipient-signing';
+import { AppError } from '@documenso/lib/errors/app-error';
 import { completeDocumentWithToken } from '@documenso/lib/server-only/document/complete-document-with-token';
 import { rejectDocumentWithToken } from '@documenso/lib/server-only/document/reject-document-with-token';
 import { createEnvelopeRecipients } from '@documenso/lib/server-only/recipient/create-envelope-recipients';
@@ -11,7 +12,6 @@ import { isTspEnvelope } from '@documenso/lib/types/signature-level';
 import { unsafeBuildEnvelopeIdQuery } from '@documenso/lib/utils/envelope';
 import { prisma } from '@documenso/prisma';
 import { EnvelopeType } from '@prisma/client';
-
 import { ZGenericSuccessResponse, ZSuccessResponseSchema } from '../schema';
 import { authenticatedProcedure, procedure, router } from '../trpc';
 import { findRecipientSuggestionsRoute } from './find-recipient-suggestions';
@@ -590,47 +590,61 @@ export const recipientRouter = router({
     .input(ZCompleteDocumentWithTokenMutationSchema)
     .output(ZCompleteDocumentWithTokenResponseSchema)
     .mutation(async ({ input, ctx }) => {
-      const { token, documentId, accessAuthOptions, nextSigner, recipientOverride } = input;
+      try {
+        const { token, documentId, accessAuthOptions, nextSigner, recipientOverride } = input;
 
-      ctx.logger.info({
+        ctx.logger.info({
-        input: {
+          input: {
-          documentId,
+            documentId,
-        },
+          },
-      });
+        });
 
-      // Branch on TSP envelopes before any SES side effects: TSP recipients
+        // Branch on TSP envelopes before any SES side effects: TSP recipients
-      // can't complete via this route — they go through the CSC sync sign
+        // can't complete via this route — they go through the CSC sync sign
-      // flow (`enterprise.csc.signEnvelope`). This route returns the redirect URL
+        // flow (`enterprise.csc.signEnvelope`). This route returns the redirect URL
-      // for the credential-scope OAuth round-trip.
+        // for the credential-scope OAuth round-trip.
-      const envelope = await prisma.envelope.findFirstOrThrow({
+        const envelope = await prisma.envelope.findFirstOrThrow({
-        where: {
+          where: {
-          ...unsafeBuildEnvelopeIdQuery({ type: 'documentId', id: documentId }, EnvelopeType.DOCUMENT),
+            ...unsafeBuildEnvelopeIdQuery({ type: 'documentId', id: documentId }, EnvelopeType.DOCUMENT),
-          recipients: { some: { token } },
+            recipients: { some: { token } },
-        },
+          },
-        select: { signatureLevel: true, internalVersion: true },
+          select: { signatureLevel: true, internalVersion: true },
-      });
+        });
 
-      if (isTspEnvelope(envelope)) {
+        if (isTspEnvelope(envelope)) {
-        return await prepareCscRecipientSigning({
+          return await prepareCscRecipientSigning({
-          recipientToken: token,
+            recipientToken: token,
+            requestMetadata: ctx.metadata.requestMetadata,
+          });
+        }
+
+        await completeDocumentWithToken({
+          token,
+          id: {
+            type: 'documentId',
+            id: documentId,
+          },
+          accessAuthOptions,
+          nextSigner,
+          recipientOverride,
+          userId: ctx.user?.id,
           requestMetadata: ctx.metadata.requestMetadata,
         });
+
+        return { status: 'SIGNED' as const };
+      } catch (err) {
+        // Log the error for debugging purposes.
+        ctx.logger.error({
+          message: 'Error completing document with token',
+          error: err instanceof AppError ? `[${err.code}]: ${err.message}` : String(err),
+        });
+
+        // Raw console.log incase we're somehow dealing with a funky error object that doesn't serialize well.
+        console.log('Error completing document with token', err);
+
+        // Rethrow the error so that the client receives the appropriate error response.
+        throw err;
       }
-
-      await completeDocumentWithToken({
-        token,
-        id: {
-          type: 'documentId',
-          id: documentId,
-        },
-        accessAuthOptions,
-        nextSigner,
-        recipientOverride,
-        userId: ctx.user?.id,
-        requestMetadata: ctx.metadata.requestMetadata,
-      });
-
-      return { status: 'SIGNED' as const };
     }),
 
   /**