feat: migrate nextjs to rr7

packages/lib/jobs/definitions/emails/send-bulk-complete-email.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+
+import { ZRequestMetadataSchema } from '../../../universal/extract-request-metadata';
+import { type JobDefinition } from '../../client/_internal/job';
+
+const SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_ID = 'send.bulk.complete.email';
+
+const SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
+  userId: z.number(),
+  templateId: z.number(),
+  templateName: z.string(),
+  totalProcessed: z.number(),
+  successCount: z.number(),
+  failedCount: z.number(),
+  errors: z.array(z.string()),
+  requestMetadata: ZRequestMetadataSchema.optional(),
+});
+
+export type TSendBulkCompleteEmailJobDefinition = z.infer<
+  typeof SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_SCHEMA
+>;
+
+export const SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION = {
+  id: SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_ID,
+  name: 'Send Bulk Complete Email',
+  version: '1.0.0',
+  trigger: {
+    name: SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_ID,
+    schema: SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./send-bulk-complete-email.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof SEND_BULK_COMPLETE_EMAIL_JOB_DEFINITION_ID,
+  TSendBulkCompleteEmailJobDefinition
+>;

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-password-reset-success-email.handler.ts

@@ -0,0 +1,12 @@
+import { sendResetPassword } from '../../../server-only/auth/send-reset-password';
+import type { TSendPasswordResetSuccessEmailJobDefinition } from './send-password-reset-success-email';
+
+export const run = async ({
+  payload,
+}: {
+  payload: TSendPasswordResetSuccessEmailJobDefinition;
+}) => {
+  await sendResetPassword({
+    userId: payload.userId,
+  });
+};

packages/lib/jobs/definitions/emails/send-password-reset-success-email.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+
+import type { JobDefinition } from '../../client/_internal/job';
+
+const SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_ID = 'send.password.reset.success.email';
+
+const SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
+  userId: z.number(),
+});
+
+export type TSendPasswordResetSuccessEmailJobDefinition = z.infer<
+  typeof SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_SCHEMA
+>;
+
+export const SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION = {
+  id: SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_ID,
+  name: 'Send Password Reset Email',
+  version: '1.0.0',
+  trigger: {
+    name: SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_ID,
+    schema: SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload }) => {
+    const handler = await import('./send-password-reset-success-email.handler');
+
+    await handler.run({ payload });
+  },
+} as const satisfies JobDefinition<
+  typeof SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_ID,
+  TSendPasswordResetSuccessEmailJobDefinition
+>;

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

@@ -0,0 +1,117 @@
+import { createElement } from 'react';
+
+import { msg } from '@lingui/core/macro';
+
+import { mailer } from '@documenso/email/mailer';
+import { DocumentRecipientSignedEmailTemplate } from '@documenso/email/templates/document-recipient-signed';
+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 { TSendRecipientSignedEmailJobDefinition } from './send-recipient-signed-email';
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TSendRecipientSignedEmailJobDefinition;
+  io: JobRunIO;
+}) => {
+  const { documentId, recipientId } = payload;
+
+  const document = await prisma.document.findFirst({
+    where: {
+      id: documentId,
+      recipients: {
+        some: {
+          id: recipientId,
+        },
+      },
+    },
+    include: {
+      recipients: {
+        where: {
+          id: recipientId,
+        },
+      },
+      user: true,
+      documentMeta: true,
+      team: {
+        include: {
+          teamGlobalSettings: true,
+        },
+      },
+    },
+  });
+
+  if (!document) {
+    throw new Error('Document not found');
+  }
+
+  if (document.recipients.length === 0) {
+    throw new Error('Document has no recipients');
+  }
+
+  const isRecipientSignedEmailEnabled = extractDerivedDocumentEmailSettings(
+    document.documentMeta,
+  ).recipientSigned;
+
+  if (!isRecipientSignedEmailEnabled) {
+    return;
+  }
+
+  const [recipient] = document.recipients;
+  const { email: recipientEmail, name: recipientName } = recipient;
+  const { user: owner } = document;
+
+  const recipientReference = recipientName || recipientEmail;
+
+  // Don't send notification if the owner is the one who signed
+  if (owner.email === recipientEmail) {
+    return;
+  }
+
+  const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
+  const i18n = await getI18nInstance(document.documentMeta?.language);
+
+  const template = createElement(DocumentRecipientSignedEmailTemplate, {
+    documentName: document.title,
+    recipientName,
+    recipientEmail,
+    assetBaseUrl,
+  });
+
+  await io.runTask('send-recipient-signed-email', async () => {
+    const branding = document.team?.teamGlobalSettings
+      ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
+      : undefined;
+
+    const [html, text] = await Promise.all([
+      renderEmailWithI18N(template, { lang: document.documentMeta?.language, branding }),
+      renderEmailWithI18N(template, {
+        lang: document.documentMeta?.language,
+        branding,
+        plainText: true,
+      }),
+    ]);
+
+    await mailer.sendMail({
+      to: {
+        name: owner.name ?? '',
+        address: owner.email,
+      },
+      from: {
+        name: FROM_NAME,
+        address: FROM_ADDRESS,
+      },
+      subject: i18n._(msg`${recipientReference} has signed "${document.title}"`),
+      html,
+      text,
+    });
+  });
+};

packages/lib/jobs/definitions/emails/send-recipient-signed-email.ts

@@ -1,18 +1,5 @@
-import { createElement } from 'react';
-
-import { msg } from '@lingui/macro';
 import { z } from 'zod';
 
-import { mailer } from '@documenso/email/mailer';
-import { DocumentRecipientSignedEmailTemplate } from '@documenso/email/templates/document-recipient-signed';
-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 JobDefinition } from '../../client/_internal/job';
 
 const SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION_ID = 'send.recipient.signed.email';
@@ -22,6 +9,10 @@ const SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
   recipientId: z.number(),
 });
 
+export type TSendRecipientSignedEmailJobDefinition = z.infer<
+  typeof SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION_SCHEMA
+>;
+
 export const SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION = {
   id: SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION_ID,
   name: 'Send Recipient Signed Email',
@@ -31,98 +22,9 @@ export const SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION = {
     schema: SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION_SCHEMA,
   },
   handler: async ({ payload, io }) => {
-    const { documentId, recipientId } = payload;
+    const handler = await import('./send-recipient-signed-email.handler');
 
-    const document = await prisma.document.findFirst({
-      where: {
-        id: documentId,
-        recipients: {
-          some: {
-            id: recipientId,
-          },
-        },
-      },
-      include: {
-        recipients: {
-          where: {
-            id: recipientId,
-          },
-        },
-        user: true,
-        documentMeta: true,
-        team: {
-          include: {
-            teamGlobalSettings: true,
-          },
-        },
-      },
-    });
-
-    if (!document) {
-      throw new Error('Document not found');
-    }
-
-    if (document.recipients.length === 0) {
-      throw new Error('Document has no recipients');
-    }
-
-    const isRecipientSignedEmailEnabled = extractDerivedDocumentEmailSettings(
-      document.documentMeta,
-    ).recipientSigned;
-
-    if (!isRecipientSignedEmailEnabled) {
-      return;
-    }
-
-    const [recipient] = document.recipients;
-    const { email: recipientEmail, name: recipientName } = recipient;
-    const { user: owner } = document;
-
-    const recipientReference = recipientName || recipientEmail;
-
-    // Don't send notification if the owner is the one who signed
-    if (owner.email === recipientEmail) {
-      return;
-    }
-
-    const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
-    const i18n = await getI18nInstance(document.documentMeta?.language);
-
-    const template = createElement(DocumentRecipientSignedEmailTemplate, {
-      documentName: document.title,
-      recipientName,
-      recipientEmail,
-      assetBaseUrl,
-    });
-
-    await io.runTask('send-recipient-signed-email', async () => {
-      const branding = document.team?.teamGlobalSettings
-        ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
-        : undefined;
-
-      const [html, text] = await Promise.all([
-        renderEmailWithI18N(template, { lang: document.documentMeta?.language, branding }),
-        renderEmailWithI18N(template, {
-          lang: document.documentMeta?.language,
-          branding,
-          plainText: true,
-        }),
-      ]);
-
-      await mailer.sendMail({
-        to: {
-          name: owner.name ?? '',
-          address: owner.email,
-        },
-        from: {
-          name: FROM_NAME,
-          address: FROM_ADDRESS,
-        },
-        subject: i18n._(msg`${recipientReference} has signed "${document.title}"`),
-        html,
-        text,
-      });
-    });
+    await handler.run({ payload, io });
   },
 } as const satisfies JobDefinition<
   typeof SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION_ID,

packages/lib/jobs/definitions/emails/send-rejection-emails.handler.ts

@@ -1,14 +1,14 @@
 import { createElement } from 'react';
 
-import { msg } from '@lingui/macro';
+import { msg } from '@lingui/core/macro';
+import { SendStatus, SigningStatus } from '@prisma/client';
 
 import { mailer } from '@documenso/email/mailer';
 import DocumentRejectedEmail from '@documenso/email/templates/document-rejected';
 import DocumentRejectionConfirmedEmail from '@documenso/email/templates/document-rejection-confirmed';
 import { prisma } from '@documenso/prisma';
-import { SendStatus, SigningStatus } from '@documenso/prisma/client';
 
-import { getI18nInstance } from '../../../client-only/providers/i18n.server';
+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';

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

@@ -1,18 +1,13 @@
 import { createElement } from 'react';
 
-import { msg } from '@lingui/macro';
+import { msg } from '@lingui/core/macro';
+import { DocumentSource, DocumentStatus, RecipientRole, SendStatus } from '@prisma/client';
 
 import { mailer } from '@documenso/email/mailer';
 import DocumentInviteEmailTemplate from '@documenso/email/templates/document-invite';
 import { prisma } from '@documenso/prisma';
-import {
-  DocumentSource,
-  DocumentStatus,
-  RecipientRole,
-  SendStatus,
-} from '@documenso/prisma/client';
 
-import { getI18nInstance } from '../../../client-only/providers/i18n.server';
+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 {
@@ -119,9 +114,11 @@ export const run = async ({
     emailMessage = customEmail?.message ?? '';
 
     if (!emailMessage) {
+      const inviterName = user.name || '';
+
       emailMessage = i18n._(
         team.teamGlobalSettings?.includeSenderDetails
-          ? msg`${user.name} on behalf of "${team.name}" has invited you to ${recipientActionVerb} the document "${document.title}".`
+          ? 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}".`,
       );
     }

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

@@ -1,7 +1,6 @@
+import { DocumentVisibility } from '@prisma/client';
 import { z } from 'zod';
 
-import { DocumentVisibility } from '@documenso/prisma/client';
-
 import type { JobDefinition } from '../../client/_internal/job';
 
 const SEND_TEAM_DELETED_EMAIL_JOB_DEFINITION_ID = 'send.team-deleted.email';

packages/lib/jobs/definitions/emails/send-team-member-joined-email.handler.ts

@@ -1,14 +1,14 @@
 import { createElement } from 'react';
 
-import { msg } from '@lingui/macro';
+import { msg } from '@lingui/core/macro';
+import { TeamMemberRole } from '@prisma/client';
 
 import { mailer } from '@documenso/email/mailer';
 import TeamJoinEmailTemplate from '@documenso/email/templates/team-join';
 import { prisma } from '@documenso/prisma';
-import { TeamMemberRole } from '@documenso/prisma/client';
 
-import { getI18nInstance } from '../../../client-only/providers/i18n.server';
-import { WEBAPP_BASE_URL } from '../../../constants/app';
+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 { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';
 import { teamGlobalSettingsToBranding } from '../../../utils/team-global-settings-to-branding';
@@ -60,8 +60,8 @@ export const run = async ({
       `send-team-member-joined-email--${invitedMember.id}_${member.id}`,
       async () => {
         const emailContent = createElement(TeamJoinEmailTemplate, {
-          assetBaseUrl: WEBAPP_BASE_URL,
-          baseUrl: WEBAPP_BASE_URL,
+          assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+          baseUrl: NEXT_PUBLIC_WEBAPP_URL(),
           memberName: invitedMember.user.name || '',
           memberEmail: invitedMember.user.email,
           teamName: team.name,

packages/lib/jobs/definitions/emails/send-team-member-left-email.handler.ts

@@ -1,14 +1,14 @@
 import { createElement } from 'react';
 
-import { msg } from '@lingui/macro';
+import { msg } from '@lingui/core/macro';
+import { TeamMemberRole } from '@prisma/client';
 
 import { mailer } from '@documenso/email/mailer';
 import TeamJoinEmailTemplate from '@documenso/email/templates/team-join';
 import { prisma } from '@documenso/prisma';
-import { TeamMemberRole } from '@documenso/prisma/client';
 
-import { getI18nInstance } from '../../../client-only/providers/i18n.server';
-import { WEBAPP_BASE_URL } from '../../../constants/app';
+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 { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';
 import { teamGlobalSettingsToBranding } from '../../../utils/team-global-settings-to-branding';
@@ -50,8 +50,8 @@ export const run = async ({
   for (const member of team.members) {
     await io.runTask(`send-team-member-left-email--${oldMember.id}_${member.id}`, async () => {
       const emailContent = createElement(TeamJoinEmailTemplate, {
-        assetBaseUrl: WEBAPP_BASE_URL,
-        baseUrl: WEBAPP_BASE_URL,
+        assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+        baseUrl: NEXT_PUBLIC_WEBAPP_URL(),
         memberName: oldMember.name || '',
         memberEmail: oldMember.email,
         teamName: team.name,

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

@@ -0,0 +1,208 @@
+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';
+
+import { mailer } from '@documenso/email/mailer';
+import { BulkSendCompleteEmail } from '@documenso/email/templates/bulk-send-complete';
+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 { getI18nInstance } from '../../../client-only/providers/i18n-server';
+import { NEXT_PUBLIC_WEBAPP_URL } from '../../../constants/app';
+import { FROM_ADDRESS, FROM_NAME } from '../../../constants/email';
+import { AppError } from '../../../errors/app-error';
+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 { TBulkSendTemplateJobDefinition } from './bulk-send-template';
+
+const ZRecipientRowSchema = z.object({
+  name: z.string().optional(),
+  email: z.union([
+    z.string().email({ message: 'Value must be a valid email or empty string' }),
+    z.string().max(0, { message: 'Value must be a valid email or empty string' }),
+  ]),
+});
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TBulkSendTemplateJobDefinition;
+  io: JobRunIO;
+}) => {
+  const { userId, teamId, templateId, csvContent, sendImmediately, requestMetadata } = payload;
+
+  const template = await getTemplateById({
+    id: templateId,
+    userId,
+    teamId,
+  });
+
+  if (!template) {
+    throw new Error('Template not found');
+  }
+
+  const rows = parse(csvContent, { columns: true, skip_empty_lines: true });
+
+  if (rows.length > 100) {
+    throw new Error('Maximum 100 rows allowed per upload');
+  }
+
+  const { recipients } = template;
+
+  // Validate CSV structure
+  const csvHeaders = Object.keys(rows[0]);
+  const requiredHeaders = recipients.map((_, index) => `recipient_${index + 1}_email`);
+
+  for (const header of requiredHeaders) {
+    if (!csvHeaders.includes(header)) {
+      throw new Error(`Missing required column: ${header}`);
+    }
+  }
+
+  const user = await prisma.user.findFirstOrThrow({
+    where: {
+      id: userId,
+    },
+    select: {
+      email: true,
+      name: true,
+    },
+  });
+
+  const results = {
+    success: 0,
+    failed: 0,
+    errors: Array<string>(),
+  };
+
+  // Process each row
+  for (const [rowIndex, row] of rows.entries()) {
+    try {
+      for (const [recipientIndex] of recipients.entries()) {
+        const nameKey = `recipient_${recipientIndex + 1}_name`;
+        const emailKey = `recipient_${recipientIndex + 1}_email`;
+
+        const parsed = ZRecipientRowSchema.safeParse({
+          name: row[nameKey],
+          email: row[emailKey],
+        });
+
+        if (!parsed.success) {
+          throw new Error(
+            `Invalid recipient data provided for ${emailKey}, ${nameKey}: ${parsed.error.issues?.[0]?.message}`,
+          );
+        }
+      }
+
+      const document = await io.runTask(`create-document-${rowIndex}`, async () => {
+        return await createDocumentFromTemplate({
+          templateId: template.id,
+          userId,
+          teamId,
+          recipients: recipients.map((recipient, index) => {
+            return {
+              id: recipient.id,
+              email: row[`recipient_${index + 1}_email`] || recipient.email,
+              name: row[`recipient_${index + 1}_name`] || recipient.name,
+              role: recipient.role,
+              signingOrder: recipient.signingOrder,
+            };
+          }),
+          requestMetadata: {
+            source: 'app',
+            auth: 'session',
+            requestMetadata: requestMetadata || {},
+          },
+        });
+      });
+
+      if (sendImmediately) {
+        await io.runTask(`send-document-${rowIndex}`, async () => {
+          await sendDocument({
+            documentId: document.id,
+            userId,
+            teamId,
+            requestMetadata: {
+              source: 'app',
+              auth: 'session',
+              requestMetadata: requestMetadata || {},
+            },
+          }).catch((err) => {
+            console.error(err);
+
+            throw new AppError('DOCUMENT_SEND_FAILED');
+          });
+        });
+      }
+
+      results.success += 1;
+    } catch (error) {
+      results.failed += 1;
+
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      results.errors.push(`Row ${rowIndex + 1}: Was unable to be processed - ${errorMessage}`);
+    }
+  }
+
+  await io.runTask('send-completion-email', async () => {
+    const completionTemplate = createElement(BulkSendCompleteEmail, {
+      userName: user.name || user.email,
+      templateName: template.title,
+      totalProcessed: rows.length,
+      successCount: results.success,
+      failedCount: results.failed,
+      errors: results.errors,
+      assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+    });
+
+    let teamGlobalSettings: TeamGlobalSettings | undefined | null;
+
+    if (template.teamId) {
+      teamGlobalSettings = await prisma.teamGlobalSettings.findUnique({
+        where: {
+          teamId: template.teamId,
+        },
+      });
+    }
+
+    const branding = teamGlobalSettings
+      ? teamGlobalSettingsToBranding(teamGlobalSettings)
+      : undefined;
+
+    const i18n = await getI18nInstance(teamGlobalSettings?.documentLanguage);
+
+    const [html, text] = await Promise.all([
+      renderEmailWithI18N(completionTemplate, {
+        lang: teamGlobalSettings?.documentLanguage,
+        branding,
+      }),
+      renderEmailWithI18N(completionTemplate, {
+        lang: teamGlobalSettings?.documentLanguage,
+        branding,
+        plainText: true,
+      }),
+    ]);
+
+    await mailer.sendMail({
+      to: {
+        name: user.name || '',
+        address: user.email,
+      },
+      from: {
+        name: FROM_NAME,
+        address: FROM_ADDRESS,
+      },
+      subject: i18n._(msg`Bulk Send Complete: ${template.title}`),
+      html,
+      text,
+    });
+  });
+};

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+
+import { ZRequestMetadataSchema } from '../../../universal/extract-request-metadata';
+import { type JobDefinition } from '../../client/_internal/job';
+
+const BULK_SEND_TEMPLATE_JOB_DEFINITION_ID = 'internal.bulk-send-template';
+
+const BULK_SEND_TEMPLATE_JOB_DEFINITION_SCHEMA = z.object({
+  userId: z.number(),
+  teamId: z.number().optional(),
+  templateId: z.number(),
+  csvContent: z.string(),
+  sendImmediately: z.boolean(),
+  requestMetadata: ZRequestMetadataSchema.optional(),
+});
+
+export type TBulkSendTemplateJobDefinition = z.infer<
+  typeof BULK_SEND_TEMPLATE_JOB_DEFINITION_SCHEMA
+>;
+
+export const BULK_SEND_TEMPLATE_JOB_DEFINITION = {
+  id: BULK_SEND_TEMPLATE_JOB_DEFINITION_ID,
+  name: 'Bulk Send Template',
+  version: '1.0.0',
+  trigger: {
+    name: BULK_SEND_TEMPLATE_JOB_DEFINITION_ID,
+    schema: BULK_SEND_TEMPLATE_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./bulk-send-template.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof BULK_SEND_TEMPLATE_JOB_DEFINITION_ID,
+  TBulkSendTemplateJobDefinition
+>;

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

@@ -1,19 +1,16 @@
+import { DocumentStatus, RecipientRole, SigningStatus, WebhookTriggerEvents } from '@prisma/client';
 import { nanoid } from 'nanoid';
 import path from 'node:path';
 import { PDFDocument } from 'pdf-lib';
 
 import { prisma } from '@documenso/prisma';
-import {
-  DocumentStatus,
-  RecipientRole,
-  SigningStatus,
-  WebhookTriggerEvents,
-} from '@documenso/prisma/client';
 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';
@@ -24,9 +21,10 @@ import {
   ZWebhookDocumentSchema,
   mapDocumentToWebhookDocumentPayload,
 } from '../../../types/webhook-payload';
-import { getFile } from '../../../universal/upload/get-file';
-import { putPdfFile } from '../../../universal/upload/put-file';
+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';
@@ -43,11 +41,6 @@ export const run = async ({
   const document = await prisma.document.findFirstOrThrow({
     where: {
       id: documentId,
-      recipients: {
-        every: {
-          signingStatus: SigningStatus.SIGNED,
-        },
-      },
     },
     include: {
       documentMeta: true,
@@ -64,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
@@ -96,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: {
@@ -109,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`);
   }
 
@@ -119,7 +129,7 @@ export const run = async ({
     documentData.data = documentData.initialData;
   }
 
-  const pdfData = await getFile(documentData);
+  const pdfData = await getFileServerSide(documentData);
 
   const certificateData =
     (document.team?.teamGlobalSettings?.includeSigningCertificate ?? true)
@@ -137,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);
 
@@ -165,8 +180,11 @@ export const run = async ({
 
     const { name } = path.parse(document.title);
 
-    const documentData = await putPdfFile({
-      name: `${name}_signed.pdf`,
+    // Add suffix based on document status
+    const suffix = isRejected ? '_rejected.pdf' : '_signed.pdf';
+
+    const documentData = await putPdfFileServerSide({
+      name: `${name}${suffix}`,
       type: 'application/pdf',
       arrayBuffer: async () => Promise.resolve(pdfBuffer),
     });
@@ -182,6 +200,7 @@ export const run = async ({
       event: 'App: Document Sealed',
       properties: {
         documentId: document.id,
+        isRejected,
       },
     });
   }
@@ -199,7 +218,7 @@ export const run = async ({
           id: document.id,
         },
         data: {
-          status: DocumentStatus.COMPLETED,
+          status: isRejected ? DocumentStatus.REJECTED : DocumentStatus.COMPLETED,
           completedAt: new Date(),
         },
       });
@@ -221,6 +240,7 @@ export const run = async ({
           user: null,
           data: {
             transactionId: nanoid(),
+            ...(isRejected ? { isRejected: true, rejectionReason: rejectionReason } : {}),
           },
         }),
       });
@@ -228,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;
     }
 
@@ -251,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,