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

import { TRPCError } from '@trpc/server';

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 { setRecipientExpiry } from '@documenso/lib/server-only/recipient/set-recipient-expiry';
import { setRecipientsForDocument } from '@documenso/lib/server-only/recipient/set-recipients-for-document';
import { setRecipientsForTemplate } from '@documenso/lib/server-only/recipient/set-recipients-for-template';
import { extractNextApiRequestMetadata } from '@documenso/lib/universal/extract-request-metadata';

import { authenticatedProcedure, procedure, router } from '../trpc';
import {
  ZAddSignersMutationSchema,
  ZAddTemplateSignersMutationSchema,
  ZCompleteDocumentWithTokenMutationSchema,
  ZRejectDocumentWithTokenMutationSchema,
  ZSetSignerExpirySchema,
} from './schema';

export const recipientRouter = router({
  addSigners: authenticatedProcedure
    .input(ZAddSignersMutationSchema)
    .mutation(async ({ input, ctx }) => {
      try {
        const { documentId, teamId, signers } = input;

        return await setRecipientsForDocument({
          userId: ctx.user.id,
          documentId,
          teamId,
          recipients: signers.map((signer) => ({
            id: signer.nativeId,
            email: signer.email,
            name: signer.name,
            role: signer.role,
            signingOrder: signer.signingOrder,
            actionAuth: signer.actionAuth,
          })),
          requestMetadata: extractNextApiRequestMetadata(ctx.req),
        });
      } catch (err) {
        console.error(err);

        throw new TRPCError({
          code: 'BAD_REQUEST',
          message: 'We were unable to set this field. Please try again later.',
        });
      }
    }),

  setSignerExpiry: authenticatedProcedure
    .input(ZSetSignerExpirySchema)
    .mutation(async ({ input, ctx }) => {
      try {
        const { documentId, signerId, expiry, teamId } = input;

        return await setRecipientExpiry({
          documentId,
          recipientId: signerId,
          expiry,
          teamId,
          userId: ctx.user.id,
          requestMetadata: extractNextApiRequestMetadata(ctx.req),
        });
      } catch (error) {
        console.log(error);

        throw new TRPCError({
          code: 'BAD_REQUEST',
          message: "We're unable to set the expiry for this signer. Please try again later.",
        });
      }
    }),

  addTemplateSigners: authenticatedProcedure
    .input(ZAddTemplateSignersMutationSchema)
    .mutation(async ({ input, ctx }) => {
      try {
        const { templateId, signers, teamId } = input;

        return await setRecipientsForTemplate({
          userId: ctx.user.id,
          teamId,
          templateId,
          recipients: signers.map((signer) => ({
            id: signer.nativeId,
            email: signer.email,
            name: signer.name,
            role: signer.role,
            signingOrder: signer.signingOrder,
            actionAuth: signer.actionAuth,
          })),
        });
      } catch (err) {
        console.error(err);

        throw new TRPCError({
          code: 'BAD_REQUEST',
          message: 'We were unable to set this field. Please try again later.',
        });
      }
    }),

  completeDocumentWithToken: procedure
    .input(ZCompleteDocumentWithTokenMutationSchema)
    .mutation(async ({ input, ctx }) => {
      try {
        const { token, documentId, authOptions } = input;

        return await completeDocumentWithToken({
          token,
          documentId,
          authOptions,
          userId: ctx.user?.id,
          requestMetadata: extractNextApiRequestMetadata(ctx.req),
        });
      } catch (err) {
        console.error(err);

        throw new TRPCError({
          code: 'BAD_REQUEST',
          message: 'We were unable to sign this field. Please try again later.',
        });
      }
    }),

  rejectDocumentWithToken: procedure
    .input(ZRejectDocumentWithTokenMutationSchema)
    .mutation(async ({ input, ctx }) => {
      try {
        const { token, documentId, reason } = input;

        return await rejectDocumentWithToken({
          token,
          documentId,
          reason,
          requestMetadata: extractNextApiRequestMetadata(ctx.req),
        });
      } catch (err) {
        console.error(err);

        throw new TRPCError({
          code: 'BAD_REQUEST',
          message: 'We were unable to handle this request. Please try again later.',
        });
      }
    }),
});