Merge branch 'main' into feat/signing-reminders

packages/lib/jobs/client.ts

@@ -3,14 +3,16 @@ import { SEND_CONFIRMATION_EMAIL_JOB_DEFINITION } from './definitions/emails/sen
 import { SEND_DAILY_REMINDER_EMAIL_JOB } from './definitions/emails/send-daily-reminder-email';
 import { SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION } from './definitions/emails/send-document-cancelled-emails';
 import { SEND_HOURLY_REMINDER_EMAIL_JOB } from './definitions/emails/send-hourly-reminder-email';
+import { SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION } from './definitions/emails/send-organisation-member-joined-email';
+import { SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION } from './definitions/emails/send-organisation-member-left-email';
 import { SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION } from './definitions/emails/send-password-reset-success-email';
 import { SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION } from './definitions/emails/send-recipient-signed-email';
 import { SEND_SIGNING_REJECTION_EMAILS_JOB_DEFINITION } from './definitions/emails/send-rejection-emails';
 import { SEND_SIGNING_EMAIL_JOB_DEFINITION } from './definitions/emails/send-signing-email';
 import { SEND_TEAM_DELETED_EMAIL_JOB_DEFINITION } from './definitions/emails/send-team-deleted-email';
-import { SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION } from './definitions/emails/send-team-member-joined-email';
-import { SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION } from './definitions/emails/send-team-member-left-email';
+import { BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION } from './definitions/internal/backport-subscription-claims';
 import { BULK_SEND_TEMPLATE_JOB_DEFINITION } from './definitions/internal/bulk-send-template';
+import { EXECUTE_WEBHOOK_JOB_DEFINITION } from './definitions/internal/execute-webhook';
 import { SEAL_DOCUMENT_JOB_DEFINITION } from './definitions/internal/seal-document';
 
 /**
@@ -20,17 +22,19 @@ import { SEAL_DOCUMENT_JOB_DEFINITION } from './definitions/internal/seal-docume
 export const jobsClient = new JobClient([
   SEND_SIGNING_EMAIL_JOB_DEFINITION,
   SEND_CONFIRMATION_EMAIL_JOB_DEFINITION,
-  SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION,
-  SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION,
+  SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION,
+  SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION,
   SEND_TEAM_DELETED_EMAIL_JOB_DEFINITION,
   SEAL_DOCUMENT_JOB_DEFINITION,
   SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION,
   SEND_SIGNING_REJECTION_EMAILS_JOB_DEFINITION,
   SEND_RECIPIENT_SIGNED_EMAIL_JOB_DEFINITION,
   SEND_DOCUMENT_CANCELLED_EMAILS_JOB_DEFINITION,
+  BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION,
   BULK_SEND_TEMPLATE_JOB_DEFINITION,
   SEND_HOURLY_REMINDER_EMAIL_JOB,
   SEND_DAILY_REMINDER_EMAIL_JOB,
+  EXECUTE_WEBHOOK_JOB_DEFINITION,
 ] as const);
 
 export const jobs = jobsClient;

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

@@ -1,39 +0,0 @@
-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

@@ -9,10 +9,9 @@ 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 { getEmailContext } from '../../../server-only/email/get-email-context';
 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';
 
@@ -38,12 +37,20 @@ export const run = async ({
           teamEmail: true,
           name: true,
           url: true,
-          teamGlobalSettings: true,
         },
       },
     },
   });
 
+  const { branding, emailLanguage, senderEmail, replyToEmail } = await getEmailContext({
+    emailType: 'RECIPIENT',
+    source: {
+      type: 'team',
+      teamId: document.teamId,
+    },
+    meta: document.documentMeta,
+  });
+
   const { documentMeta, user: documentOwner } = document;
 
   // Check if document cancellation emails are enabled
@@ -53,7 +60,7 @@ export const run = async ({
     return;
   }
 
-  const i18n = await getI18nInstance(documentMeta?.language);
+  const i18n = await getI18nInstance(emailLanguage);
 
   // Send cancellation emails to all recipients who have been sent the document or viewed it
   const recipientsToNotify = document.recipients.filter(
@@ -73,14 +80,10 @@ export const run = async ({
           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: emailLanguage, branding }),
           renderEmailWithI18N(template, {
-            lang: documentMeta?.language,
+            lang: emailLanguage,
             branding,
             plainText: true,
           }),
@@ -91,10 +94,8 @@ export const run = async ({
             name: recipient.name,
             address: recipient.email,
           },
-          from: {
-            name: FROM_NAME,
-            address: FROM_ADDRESS,
-          },
+          from: senderEmail,
+          replyTo: replyToEmail,
           subject: i18n._(msg`Document "${document.title}" Cancelled`),
           html,
           text,

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

@@ -0,0 +1,108 @@
+import { createElement } from 'react';
+
+import { msg } from '@lingui/core/macro';
+
+import { mailer } from '@documenso/email/mailer';
+import OrganisationJoinEmailTemplate from '@documenso/email/templates/organisation-join';
+import { prisma } from '@documenso/prisma';
+
+import { getI18nInstance } from '../../../client-only/providers/i18n-server';
+import { NEXT_PUBLIC_WEBAPP_URL } from '../../../constants/app';
+import { ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP } from '../../../constants/organisations';
+import { getEmailContext } from '../../../server-only/email/get-email-context';
+import { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';
+import type { JobRunIO } from '../../client/_internal/job';
+import type { TSendOrganisationMemberJoinedEmailJobDefinition } from './send-organisation-member-joined-email';
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TSendOrganisationMemberJoinedEmailJobDefinition;
+  io: JobRunIO;
+}) => {
+  const organisation = await prisma.organisation.findFirstOrThrow({
+    where: {
+      id: payload.organisationId,
+    },
+    include: {
+      members: {
+        where: {
+          organisationGroupMembers: {
+            some: {
+              group: {
+                organisationRole: {
+                  in: ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP['MANAGE_ORGANISATION'],
+                },
+              },
+            },
+          },
+        },
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  const invitedMember = await prisma.organisationMember.findFirstOrThrow({
+    where: {
+      userId: payload.memberUserId,
+      organisationId: payload.organisationId,
+    },
+    include: {
+      user: true,
+    },
+  });
+
+  const { branding, emailLanguage, senderEmail } = await getEmailContext({
+    emailType: 'INTERNAL',
+    source: {
+      type: 'organisation',
+      organisationId: organisation.id,
+    },
+  });
+
+  for (const member of organisation.members) {
+    if (member.id === invitedMember.id) {
+      continue;
+    }
+
+    await io.runTask(
+      `send-organisation-member-joined-email--${invitedMember.id}_${member.id}`,
+      async () => {
+        const emailContent = createElement(OrganisationJoinEmailTemplate, {
+          assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+          baseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+          memberName: invitedMember.user.name || '',
+          memberEmail: invitedMember.user.email,
+          organisationName: organisation.name,
+          organisationUrl: organisation.url,
+        });
+
+        // !: Replace with the actual language of the recipient later
+        const [html, text] = await Promise.all([
+          renderEmailWithI18N(emailContent, {
+            lang: emailLanguage,
+            branding,
+          }),
+          renderEmailWithI18N(emailContent, {
+            lang: emailLanguage,
+            branding,
+            plainText: true,
+          }),
+        ]);
+
+        const i18n = await getI18nInstance(emailLanguage);
+
+        await mailer.sendMail({
+          to: member.user.email,
+          from: senderEmail,
+          subject: i18n._(msg`A new member has joined your organisation`),
+          html,
+          text,
+        });
+      },
+    );
+  }
+};

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+import type { JobDefinition } from '../../client/_internal/job';
+
+const SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID =
+  'send.organisation-member-joined.email';
+
+const SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
+  organisationId: z.string(),
+  memberUserId: z.number(),
+});
+
+export type TSendOrganisationMemberJoinedEmailJobDefinition = z.infer<
+  typeof SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_SCHEMA
+>;
+
+export const SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION = {
+  id: SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID,
+  name: 'Send Organisation Member Joined Email',
+  version: '1.0.0',
+  trigger: {
+    name: SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID,
+    schema: SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./send-organisation-member-joined-email.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof SEND_ORGANISATION_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID,
+  TSendOrganisationMemberJoinedEmailJobDefinition
+>;

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

@@ -0,0 +1,103 @@
+import { createElement } from 'react';
+
+import { msg } from '@lingui/core/macro';
+
+import { mailer } from '@documenso/email/mailer';
+import OrganisationLeaveEmailTemplate from '@documenso/email/templates/organisation-leave';
+import { prisma } from '@documenso/prisma';
+
+import { getI18nInstance } from '../../../client-only/providers/i18n-server';
+import { NEXT_PUBLIC_WEBAPP_URL } from '../../../constants/app';
+import { ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP } from '../../../constants/organisations';
+import { getEmailContext } from '../../../server-only/email/get-email-context';
+import { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';
+import type { JobRunIO } from '../../client/_internal/job';
+import type { TSendOrganisationMemberLeftEmailJobDefinition } from './send-organisation-member-left-email';
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TSendOrganisationMemberLeftEmailJobDefinition;
+  io: JobRunIO;
+}) => {
+  const organisation = await prisma.organisation.findFirstOrThrow({
+    where: {
+      id: payload.organisationId,
+    },
+    include: {
+      members: {
+        where: {
+          organisationGroupMembers: {
+            some: {
+              group: {
+                organisationRole: {
+                  in: ORGANISATION_MEMBER_ROLE_PERMISSIONS_MAP['MANAGE_ORGANISATION'],
+                },
+              },
+            },
+          },
+        },
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  const oldMember = await prisma.user.findFirstOrThrow({
+    where: {
+      id: payload.memberUserId,
+    },
+  });
+
+  const { branding, emailLanguage, senderEmail } = await getEmailContext({
+    emailType: 'INTERNAL',
+    source: {
+      type: 'organisation',
+      organisationId: organisation.id,
+    },
+  });
+
+  for (const member of organisation.members) {
+    if (member.userId === oldMember.id) {
+      continue;
+    }
+
+    await io.runTask(
+      `send-organisation-member-left-email--${oldMember.id}_${member.id}`,
+      async () => {
+        const emailContent = createElement(OrganisationLeaveEmailTemplate, {
+          assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+          baseUrl: NEXT_PUBLIC_WEBAPP_URL(),
+          memberName: oldMember.name || '',
+          memberEmail: oldMember.email,
+          organisationName: organisation.name,
+          organisationUrl: organisation.url,
+        });
+
+        const [html, text] = await Promise.all([
+          renderEmailWithI18N(emailContent, {
+            lang: emailLanguage,
+            branding,
+          }),
+          renderEmailWithI18N(emailContent, {
+            lang: emailLanguage,
+            branding,
+            plainText: true,
+          }),
+        ]);
+
+        const i18n = await getI18nInstance(emailLanguage);
+
+        await mailer.sendMail({
+          to: member.user.email,
+          from: senderEmail,
+          subject: i18n._(msg`A member has left your organisation`),
+          html,
+          text,
+        });
+      },
+    );
+  }
+};

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+import type { JobDefinition } from '../../client/_internal/job';
+
+const SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID = 'send.organisation-member-left.email';
+
+const SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
+  organisationId: z.string(),
+  memberUserId: z.number(),
+});
+
+export type TSendOrganisationMemberLeftEmailJobDefinition = z.infer<
+  typeof SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_SCHEMA
+>;
+
+export const SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION = {
+  id: SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID,
+  name: 'Send Organisation Member Left Email',
+  version: '1.0.0',
+  trigger: {
+    name: SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID,
+    schema: SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./send-organisation-member-left-email.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof SEND_ORGANISATION_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID,
+  TSendOrganisationMemberLeftEmailJobDefinition
+>;

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

@@ -8,10 +8,9 @@ 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 { getEmailContext } from '../../../server-only/email/get-email-context';
 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';
 
@@ -41,11 +40,6 @@ export const run = async ({
       },
       user: true,
       documentMeta: true,
-      team: {
-        include: {
-          teamGlobalSettings: true,
-        },
-      },
     },
   });
 
@@ -76,8 +70,18 @@ export const run = async ({
     return;
   }
 
+  const { branding, emailLanguage, senderEmail } = await getEmailContext({
+    emailType: 'INTERNAL',
+    source: {
+      type: 'team',
+      teamId: document.teamId,
+    },
+    meta: document.documentMeta,
+  });
+
   const assetBaseUrl = NEXT_PUBLIC_WEBAPP_URL() || 'http://localhost:3000';
-  const i18n = await getI18nInstance(document.documentMeta?.language);
+
+  const i18n = await getI18nInstance(emailLanguage);
 
   const template = createElement(DocumentRecipientSignedEmailTemplate, {
     documentName: document.title,
@@ -87,14 +91,10 @@ export const run = async ({
   });
 
   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: emailLanguage, branding }),
       renderEmailWithI18N(template, {
-        lang: document.documentMeta?.language,
+        lang: emailLanguage,
         branding,
         plainText: true,
       }),
@@ -105,10 +105,7 @@ export const run = async ({
         name: owner.name ?? '',
         address: owner.email,
       },
-      from: {
-        name: FROM_NAME,
-        address: FROM_ADDRESS,
-      },
+      from: senderEmail,
       subject: i18n._(msg`${recipientReference} has signed "${document.title}"`),
       html,
       text,

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

@@ -10,10 +10,10 @@ 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 { DOCUMENSO_INTERNAL_EMAIL } from '../../../constants/email';
+import { getEmailContext } from '../../../server-only/email/get-email-context';
 import { extractDerivedDocumentEmailSettings } from '../../../types/document-email';
 import { renderEmailWithI18N } from '../../../utils/render-email-with-i18n';
-import { teamGlobalSettingsToBranding } from '../../../utils/team-global-settings-to-branding';
 import { formatDocumentsPath } from '../../../utils/teams';
 import type { JobRunIO } from '../../client/_internal/job';
 import type { TSendSigningRejectionEmailsJobDefinition } from './send-rejection-emails';
@@ -40,7 +40,6 @@ export const run = async ({
             teamEmail: true,
             name: true,
             url: true,
-            teamGlobalSettings: true,
           },
         },
       },
@@ -53,7 +52,7 @@ export const run = async ({
     }),
   ]);
 
-  const { documentMeta, user: documentOwner } = document;
+  const { user: documentOwner } = document;
 
   const isEmailEnabled = extractDerivedDocumentEmailSettings(
     document.documentMeta,
@@ -63,7 +62,16 @@ export const run = async ({
     return;
   }
 
-  const i18n = await getI18nInstance(documentMeta?.language);
+  const { branding, emailLanguage, senderEmail, replyToEmail } = await getEmailContext({
+    emailType: 'RECIPIENT',
+    source: {
+      type: 'team',
+      teamId: document.teamId,
+    },
+    meta: document.documentMeta,
+  });
+
+  const i18n = await getI18nInstance(emailLanguage);
 
   // Send confirmation email to the recipient who rejected
   await io.runTask('send-rejection-confirmation-email', async () => {
@@ -75,14 +83,10 @@ export const run = async ({
       assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
     });
 
-    const branding = document.team?.teamGlobalSettings
-      ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
-      : undefined;
-
     const [html, text] = await Promise.all([
-      renderEmailWithI18N(recipientTemplate, { lang: documentMeta?.language, branding }),
+      renderEmailWithI18N(recipientTemplate, { lang: emailLanguage, branding }),
       renderEmailWithI18N(recipientTemplate, {
-        lang: documentMeta?.language,
+        lang: emailLanguage,
         branding,
         plainText: true,
       }),
@@ -93,10 +97,8 @@ export const run = async ({
         name: recipient.name,
         address: recipient.email,
       },
-      from: {
-        name: FROM_NAME,
-        address: FROM_ADDRESS,
-      },
+      from: senderEmail,
+      replyTo: replyToEmail,
       subject: i18n._(msg`Document "${document.title}" - Rejection Confirmed`),
       html,
       text,
@@ -115,14 +117,10 @@ export const run = async ({
       assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
     });
 
-    const branding = document.team?.teamGlobalSettings
-      ? teamGlobalSettingsToBranding(document.team.teamGlobalSettings)
-      : undefined;
-
     const [html, text] = await Promise.all([
-      renderEmailWithI18N(ownerTemplate, { lang: documentMeta?.language, branding }),
+      renderEmailWithI18N(ownerTemplate, { lang: emailLanguage, branding }),
       renderEmailWithI18N(ownerTemplate, {
-        lang: documentMeta?.language,
+        lang: emailLanguage,
         branding,
         plainText: true,
       }),
@@ -133,10 +131,7 @@ export const run = async ({
         name: documentOwner.name || '',
         address: documentOwner.email,
       },
-      from: {
-        name: FROM_NAME,
-        address: FROM_ADDRESS,
-      },
+      from: DOCUMENSO_INTERNAL_EMAIL, // Purposefully using internal email here.
       subject: i18n._(msg`Document "${document.title}" - Rejected by ${recipient.name}`),
       html,
       text,

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

@@ -1,7 +1,13 @@
 import { createElement } from 'react';
 
 import { msg } from '@lingui/core/macro';
-import { DocumentSource, DocumentStatus, RecipientRole, SendStatus } from '@prisma/client';
+import {
+  DocumentSource,
+  DocumentStatus,
+  OrganisationType,
+  RecipientRole,
+  SendStatus,
+} from '@prisma/client';
 
 import { mailer } from '@documenso/email/mailer';
 import DocumentInviteEmailTemplate from '@documenso/email/templates/document-invite';
@@ -9,17 +15,16 @@ 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 {
   RECIPIENT_ROLES_DESCRIPTION,
   RECIPIENT_ROLE_TO_EMAIL_TYPE,
 } from '../../../constants/recipient-roles';
+import { getEmailContext } from '../../../server-only/email/get-email-context';
 import { DOCUMENT_AUDIT_LOG_TYPE } from '../../../types/document-audit-logs';
 import { extractDerivedDocumentEmailSettings } from '../../../types/document-email';
 import { createDocumentAuditLogData } from '../../../utils/document-audit-logs';
 import { renderCustomEmailTemplate } from '../../../utils/render-custom-email-template';
 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 { TSendSigningEmailJobDefinition } from './send-signing-email';
 
@@ -49,7 +54,6 @@ export const run = async ({
           select: {
             teamEmail: true,
             name: true,
-            teamGlobalSettings: true,
           },
         },
       },
@@ -75,16 +79,25 @@ export const run = async ({
     return;
   }
 
+  const { branding, emailLanguage, settings, organisationType, senderEmail, replyToEmail } =
+    await getEmailContext({
+      emailType: 'RECIPIENT',
+      source: {
+        type: 'team',
+        teamId: document.teamId,
+      },
+      meta: document.documentMeta,
+    });
+
   const customEmail = document?.documentMeta;
   const isDirectTemplate = document.source === DocumentSource.TEMPLATE_DIRECT_LINK;
-  const isTeamDocument = document.teamId !== null;
 
   const recipientEmailType = RECIPIENT_ROLE_TO_EMAIL_TYPE[recipient.role];
 
   const { email, name } = recipient;
   const selfSigner = email === user.email;
 
-  const i18n = await getI18nInstance(documentMeta?.language);
+  const i18n = await getI18nInstance(emailLanguage);
 
   const recipientActionVerb = i18n
     ._(RECIPIENT_ROLES_DESCRIPTION[recipient.role].actionVerb)
@@ -109,7 +122,7 @@ export const run = async ({
     );
   }
 
-  if (isTeamDocument && team) {
+  if (organisationType === OrganisationType.ORGANISATION) {
     emailSubject = i18n._(msg`${team.name} invited you to ${recipientActionVerb} a document`);
     emailMessage = customEmail?.message ?? '';
 
@@ -117,7 +130,7 @@ export const run = async ({
       const inviterName = user.name || '';
 
       emailMessage = i18n._(
-        team.teamGlobalSettings?.includeSenderDetails
+        settings.includeSenderDetails
           ? 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}".`,
       );
@@ -136,27 +149,26 @@ export const run = async ({
   const template = createElement(DocumentInviteEmailTemplate, {
     documentName: document.title,
     inviterName: user.name || undefined,
-    inviterEmail: isTeamDocument ? team?.teamEmail?.email || user.email : user.email,
+    inviterEmail:
+      organisationType === OrganisationType.ORGANISATION
+        ? team?.teamEmail?.email || user.email
+        : user.email,
     assetBaseUrl,
     signDocumentLink,
     customBody: renderCustomEmailTemplate(emailMessage, customEmailTemplate),
     role: recipient.role,
     selfSigner,
-    isTeamInvite: isTeamDocument,
+    organisationType,
     teamName: team?.name,
     teamEmail: team?.teamEmail?.email,
-    includeSenderDetails: team?.teamGlobalSettings?.includeSenderDetails,
+    includeSenderDetails: settings.includeSenderDetails,
   });
 
   await io.runTask('send-signing-email', async () => {
-    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: emailLanguage, branding }),
       renderEmailWithI18N(template, {
-        lang: documentMeta?.language,
+        lang: emailLanguage,
         branding,
         plainText: true,
       }),
@@ -167,10 +179,8 @@ export const run = async ({
         name: recipient.name,
         address: recipient.email,
       },
-      from: {
-        name: FROM_NAME,
-        address: FROM_ADDRESS,
-      },
+      from: senderEmail,
+      replyTo: replyToEmail,
       subject: renderCustomEmailTemplate(
         documentMeta?.subject || emailSubject,
         customEmailTemplate,

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

@@ -9,14 +9,14 @@ export const run = async ({
   payload: TSendTeamDeletedEmailJobDefinition;
   io: JobRunIO;
 }) => {
-  const { team, members } = payload;
+  const { team, members, organisationId } = payload;
 
   for (const member of members) {
     await io.runTask(`send-team-deleted-email--${team.url}_${member.id}`, async () => {
       await sendTeamDeleteEmail({
         email: member.email,
         team,
-        isOwner: member.id === team.ownerUserId,
+        organisationId,
       });
     });
   }

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

@@ -1,4 +1,3 @@
-import { DocumentVisibility } from '@prisma/client';
 import { z } from 'zod';
 
 import type { JobDefinition } from '../../client/_internal/job';
@@ -6,27 +5,10 @@ import type { JobDefinition } from '../../client/_internal/job';
 const SEND_TEAM_DELETED_EMAIL_JOB_DEFINITION_ID = 'send.team-deleted.email';
 
 const SEND_TEAM_DELETED_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
+  organisationId: z.string(),
   team: z.object({
     name: z.string(),
     url: z.string(),
-    ownerUserId: z.number(),
-    teamGlobalSettings: z
-      .object({
-        documentVisibility: z.nativeEnum(DocumentVisibility),
-        documentLanguage: z.string(),
-        includeSenderDetails: z.boolean(),
-        includeSigningCertificate: z.boolean(),
-        brandingEnabled: z.boolean(),
-        brandingLogo: z.string(),
-        brandingUrl: z.string(),
-        brandingCompanyDetails: z.string(),
-        brandingHidePoweredBy: z.boolean(),
-        teamId: z.number(),
-        typedSignatureEnabled: z.boolean(),
-        uploadSignatureEnabled: z.boolean(),
-        drawSignatureEnabled: z.boolean(),
-      })
-      .nullish(),
   }),
   members: z.array(
     z.object({

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

@@ -1,105 +0,0 @@
-import { createElement } from 'react';
-
-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 { 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';
-import type { JobRunIO } from '../../client/_internal/job';
-import type { TSendTeamMemberJoinedEmailJobDefinition } from './send-team-member-joined-email';
-
-export const run = async ({
-  payload,
-  io,
-}: {
-  payload: TSendTeamMemberJoinedEmailJobDefinition;
-  io: JobRunIO;
-}) => {
-  const team = await prisma.team.findFirstOrThrow({
-    where: {
-      id: payload.teamId,
-    },
-    include: {
-      members: {
-        where: {
-          role: {
-            in: [TeamMemberRole.ADMIN, TeamMemberRole.MANAGER],
-          },
-        },
-        include: {
-          user: true,
-        },
-      },
-      teamGlobalSettings: true,
-    },
-  });
-
-  const invitedMember = await prisma.teamMember.findFirstOrThrow({
-    where: {
-      id: payload.memberId,
-      teamId: payload.teamId,
-    },
-    include: {
-      user: true,
-    },
-  });
-
-  for (const member of team.members) {
-    if (member.id === invitedMember.id) {
-      continue;
-    }
-
-    await io.runTask(
-      `send-team-member-joined-email--${invitedMember.id}_${member.id}`,
-      async () => {
-        const emailContent = createElement(TeamJoinEmailTemplate, {
-          assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
-          baseUrl: NEXT_PUBLIC_WEBAPP_URL(),
-          memberName: invitedMember.user.name || '',
-          memberEmail: invitedMember.user.email,
-          teamName: team.name,
-          teamUrl: team.url,
-        });
-
-        const branding = team.teamGlobalSettings
-          ? teamGlobalSettingsToBranding(team.teamGlobalSettings)
-          : undefined;
-
-        const lang = team.teamGlobalSettings?.documentLanguage;
-
-        // !: Replace with the actual language of the recipient later
-        const [html, text] = await Promise.all([
-          renderEmailWithI18N(emailContent, {
-            lang,
-            branding,
-          }),
-          renderEmailWithI18N(emailContent, {
-            lang,
-            branding,
-            plainText: true,
-          }),
-        ]);
-
-        const i18n = await getI18nInstance(lang);
-
-        await mailer.sendMail({
-          to: member.user.email,
-          from: {
-            name: FROM_NAME,
-            address: FROM_ADDRESS,
-          },
-          subject: i18n._(msg`A new member has joined your team`),
-          html,
-          text,
-        });
-      },
-    );
-  }
-};

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

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-
-import type { JobDefinition } from '../../client/_internal/job';
-
-const SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID = 'send.team-member-joined.email';
-
-const SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
-  teamId: z.number(),
-  memberId: z.number(),
-});
-
-export type TSendTeamMemberJoinedEmailJobDefinition = z.infer<
-  typeof SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_SCHEMA
->;
-
-export const SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION = {
-  id: SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID,
-  name: 'Send Team Member Joined Email',
-  version: '1.0.0',
-  trigger: {
-    type: 'event',
-    name: SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID,
-    schema: SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_SCHEMA,
-  },
-  handler: async ({ payload, io }) => {
-    const handler = await import('./send-team-member-joined-email.handler');
-
-    await handler.run({ payload, io });
-  },
-} as const satisfies JobDefinition<
-  typeof SEND_TEAM_MEMBER_JOINED_EMAIL_JOB_DEFINITION_ID,
-  TSendTeamMemberJoinedEmailJobDefinition
->;

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

@@ -1,93 +0,0 @@
-import { createElement } from 'react';
-
-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 { 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';
-import type { JobRunIO } from '../../client/_internal/job';
-import type { TSendTeamMemberLeftEmailJobDefinition } from './send-team-member-left-email';
-
-export const run = async ({
-  payload,
-  io,
-}: {
-  payload: TSendTeamMemberLeftEmailJobDefinition;
-  io: JobRunIO;
-}) => {
-  const team = await prisma.team.findFirstOrThrow({
-    where: {
-      id: payload.teamId,
-    },
-    include: {
-      members: {
-        where: {
-          role: {
-            in: [TeamMemberRole.ADMIN, TeamMemberRole.MANAGER],
-          },
-        },
-        include: {
-          user: true,
-        },
-      },
-      teamGlobalSettings: true,
-    },
-  });
-
-  const oldMember = await prisma.user.findFirstOrThrow({
-    where: {
-      id: payload.memberUserId,
-    },
-  });
-
-  for (const member of team.members) {
-    await io.runTask(`send-team-member-left-email--${oldMember.id}_${member.id}`, async () => {
-      const emailContent = createElement(TeamJoinEmailTemplate, {
-        assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
-        baseUrl: NEXT_PUBLIC_WEBAPP_URL(),
-        memberName: oldMember.name || '',
-        memberEmail: oldMember.email,
-        teamName: team.name,
-        teamUrl: team.url,
-      });
-
-      const branding = team.teamGlobalSettings
-        ? teamGlobalSettingsToBranding(team.teamGlobalSettings)
-        : undefined;
-
-      const lang = team.teamGlobalSettings?.documentLanguage;
-
-      const [html, text] = await Promise.all([
-        renderEmailWithI18N(emailContent, {
-          lang,
-          branding,
-        }),
-        renderEmailWithI18N(emailContent, {
-          lang,
-          branding,
-          plainText: true,
-        }),
-      ]);
-
-      const i18n = await getI18nInstance(lang);
-
-      await mailer.sendMail({
-        to: member.user.email,
-        from: {
-          name: FROM_NAME,
-          address: FROM_ADDRESS,
-        },
-        subject: i18n._(msg`A team member has left ${team.name}`),
-        html,
-        text,
-      });
-    });
-  }
-};

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

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-
-import type { JobDefinition } from '../../client/_internal/job';
-
-const SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID = 'send.team-member-left.email';
-
-const SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_SCHEMA = z.object({
-  teamId: z.number(),
-  memberUserId: z.number(),
-});
-
-export type TSendTeamMemberLeftEmailJobDefinition = z.infer<
-  typeof SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_SCHEMA
->;
-
-export const SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION = {
-  id: SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID,
-  name: 'Send Team Member Left Email',
-  version: '1.0.0',
-  trigger: {
-    type: 'event',
-    name: SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID,
-    schema: SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_SCHEMA,
-  },
-  handler: async ({ payload, io }) => {
-    const handler = await import('./send-team-member-left-email.handler');
-
-    await handler.run({ payload, io });
-  },
-} as const satisfies JobDefinition<
-  typeof SEND_TEAM_MEMBER_LEFT_EMAIL_JOB_DEFINITION_ID,
-  TSendTeamMemberLeftEmailJobDefinition
->;

packages/lib/jobs/definitions/internal/backport-subscription-claims.handler.ts

@@ -0,0 +1,35 @@
+import { prisma } from '@documenso/prisma';
+
+import { AppError, AppErrorCode } from '../../../errors/app-error';
+import type { JobRunIO } from '../../client/_internal/job';
+import type { TBackportSubscriptionClaimJobDefinition } from './backport-subscription-claims';
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TBackportSubscriptionClaimJobDefinition;
+  io: JobRunIO;
+}) => {
+  const { subscriptionClaimId, flags } = payload;
+
+  const subscriptionClaim = await prisma.subscriptionClaim.findFirst({
+    where: {
+      id: subscriptionClaimId,
+    },
+  });
+
+  if (!subscriptionClaim) {
+    throw new AppError(AppErrorCode.NOT_FOUND, { message: 'Subscription claim not found' });
+  }
+
+  await io.runTask('backport-claims', async () => {
+    const newFlagsJson = JSON.stringify(flags);
+
+    await prisma.$executeRaw`
+      UPDATE "OrganisationClaim"
+      SET "flags" = "flags" || ${newFlagsJson}::jsonb
+      WHERE "originalSubscriptionClaimId" = ${subscriptionClaimId}
+    `;
+  });
+};

packages/lib/jobs/definitions/internal/backport-subscription-claims.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+import { type JobDefinition } from '../../client/_internal/job';
+
+const BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_ID = 'internal.backport-subscription-claims';
+
+const BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_SCHEMA = z.object({
+  subscriptionClaimId: z.string(),
+  // I would prefer to fetch the subscription within the runner, but
+  // it seems the local job runs it asynchronously, so we can't get
+  // the updated values in the job.
+  flags: z.object({
+    unlimitedDocuments: z.literal(true).optional(),
+    allowCustomBranding: z.literal(true).optional(),
+    hidePoweredBy: z.literal(true).optional(),
+    embedAuthoring: z.literal(true).optional(),
+    embedAuthoringWhiteLabel: z.literal(true).optional(),
+    embedSigning: z.literal(true).optional(),
+    embedSigningWhiteLabel: z.literal(true).optional(),
+    cfr21: z.literal(true).optional(),
+  }),
+});
+
+export type TBackportSubscriptionClaimJobDefinition = z.infer<
+  typeof BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_SCHEMA
+>;
+
+export const BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION = {
+  id: BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_ID,
+  name: 'Backport Subscription Claims',
+  version: '1.0.0',
+  trigger: {
+    name: BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_ID,
+    schema: BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./backport-subscription-claims.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof BACKPORT_SUBSCRIPTION_CLAIM_JOB_DEFINITION_ID,
+  TBackportSubscriptionClaimJobDefinition
+>;

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

@@ -1,7 +1,6 @@
 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';
 
@@ -14,10 +13,9 @@ 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 { getEmailContext } from '../../../server-only/email/get-email-context';
 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';
 
@@ -163,29 +161,23 @@ export const run = async ({
       assetBaseUrl: NEXT_PUBLIC_WEBAPP_URL(),
     });
 
-    let teamGlobalSettings: TeamGlobalSettings | undefined | null;
+    const { branding, emailLanguage, senderEmail } = await getEmailContext({
+      emailType: 'INTERNAL',
+      source: {
+        type: 'team',
+        teamId,
+      },
+    });
 
-    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 i18n = await getI18nInstance(emailLanguage);
 
     const [html, text] = await Promise.all([
       renderEmailWithI18N(completionTemplate, {
-        lang: teamGlobalSettings?.documentLanguage,
+        lang: emailLanguage,
         branding,
       }),
       renderEmailWithI18N(completionTemplate, {
-        lang: teamGlobalSettings?.documentLanguage,
+        lang: emailLanguage,
         branding,
         plainText: true,
       }),
@@ -196,10 +188,7 @@ export const run = async ({
         name: user.name || '',
         address: user.email,
       },
-      from: {
-        name: FROM_NAME,
-        address: FROM_ADDRESS,
-      },
+      from: senderEmail,
       subject: i18n._(msg`Bulk Send Complete: ${template.title}`),
       html,
       text,

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

@@ -7,7 +7,7 @@ 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(),
+  teamId: z.number(),
   templateId: z.number(),
   csvContent: z.string(),
   sendImmediately: z.boolean(),

packages/lib/jobs/definitions/internal/execute-webhook.handler.ts

@@ -0,0 +1,74 @@
+import { Prisma, WebhookCallStatus } from '@prisma/client';
+
+import { prisma } from '@documenso/prisma';
+
+import type { JobRunIO } from '../../client/_internal/job';
+import type { TExecuteWebhookJobDefinition } from './execute-webhook';
+
+export const run = async ({
+  payload,
+  io,
+}: {
+  payload: TExecuteWebhookJobDefinition;
+  io: JobRunIO;
+}) => {
+  const { event, webhookId, data } = payload;
+
+  const webhook = await prisma.webhook.findUniqueOrThrow({
+    where: {
+      id: webhookId,
+    },
+  });
+
+  const { webhookUrl: url, secret } = webhook;
+
+  await io.runTask('execute-webhook', async () => {
+    const payloadData = {
+      event,
+      payload: data,
+      createdAt: new Date().toISOString(),
+      webhookEndpoint: url,
+    };
+
+    const response = await fetch(url, {
+      method: 'POST',
+      body: JSON.stringify(payloadData),
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Documenso-Secret': secret ?? '',
+      },
+    });
+
+    const body = await response.text();
+
+    let responseBody: Prisma.InputJsonValue | Prisma.JsonNullValueInput = Prisma.JsonNull;
+
+    try {
+      responseBody = JSON.parse(body);
+    } catch (err) {
+      responseBody = body;
+    }
+
+    await prisma.webhookCall.create({
+      data: {
+        url,
+        event,
+        status: response.ok ? WebhookCallStatus.SUCCESS : WebhookCallStatus.FAILED,
+        requestBody: payloadData as Prisma.InputJsonValue,
+        responseCode: response.status,
+        responseBody,
+        responseHeaders: Object.fromEntries(response.headers.entries()),
+        webhookId: webhook.id,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Webhook execution failed with status ${response.status}`);
+    }
+
+    return {
+      success: response.ok,
+      status: response.status,
+    };
+  });
+};

packages/lib/jobs/definitions/internal/execute-webhook.ts

@@ -0,0 +1,34 @@
+import { WebhookTriggerEvents } from '@prisma/client';
+import { z } from 'zod';
+
+import { ZRequestMetadataSchema } from '../../../universal/extract-request-metadata';
+import { type JobDefinition } from '../../client/_internal/job';
+
+const EXECUTE_WEBHOOK_JOB_DEFINITION_ID = 'internal.execute-webhook';
+
+const EXECUTE_WEBHOOK_JOB_DEFINITION_SCHEMA = z.object({
+  event: z.nativeEnum(WebhookTriggerEvents),
+  webhookId: z.string(),
+  data: z.unknown(),
+  requestMetadata: ZRequestMetadataSchema.optional(),
+});
+
+export type TExecuteWebhookJobDefinition = z.infer<typeof EXECUTE_WEBHOOK_JOB_DEFINITION_SCHEMA>;
+
+export const EXECUTE_WEBHOOK_JOB_DEFINITION = {
+  id: EXECUTE_WEBHOOK_JOB_DEFINITION_ID,
+  name: 'Execute Webhook',
+  version: '1.0.0',
+  trigger: {
+    name: EXECUTE_WEBHOOK_JOB_DEFINITION_ID,
+    schema: EXECUTE_WEBHOOK_JOB_DEFINITION_SCHEMA,
+  },
+  handler: async ({ payload, io }) => {
+    const handler = await import('./execute-webhook.handler');
+
+    await handler.run({ payload, io });
+  },
+} as const satisfies JobDefinition<
+  typeof EXECUTE_WEBHOOK_JOB_DEFINITION_ID,
+  TExecuteWebhookJobDefinition
+>;

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

@@ -9,18 +9,22 @@ 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 { getAuditLogsPdf } from '../../../server-only/htmltopdf/get-audit-logs-pdf';
 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';
+import { legacy_insertFieldInPDF } from '../../../server-only/pdf/legacy-insert-field-in-pdf';
 import { normalizeSignatureAppearances } from '../../../server-only/pdf/normalize-signature-appearances';
+import { getTeamSettings } from '../../../server-only/team/get-team-settings';
 import { triggerWebhook } from '../../../server-only/webhooks/trigger/trigger-webhook';
 import { DOCUMENT_AUDIT_LOG_TYPE } from '../../../types/document-audit-logs';
 import {
   ZWebhookDocumentSchema,
   mapDocumentToWebhookDocumentPayload,
 } from '../../../types/webhook-payload';
+import { prefixedId } from '../../../universal/id';
 import { getFileServerSide } from '../../../universal/upload/get-file.server';
 import { putPdfFileServerSide } from '../../../universal/upload/put-file.server';
 import { fieldsContainUnsignedRequiredField } from '../../../utils/advanced-fields-helpers';
@@ -45,18 +49,14 @@ export const run = async ({
     include: {
       documentMeta: true,
       recipients: true,
-      team: {
-        select: {
-          teamGlobalSettings: {
-            select: {
-              includeSigningCertificate: true,
-            },
-          },
-        },
-      },
     },
   });
 
+  const settings = await getTeamSettings({
+    userId: document.userId,
+    teamId: document.teamId,
+  });
+
   const isComplete =
     document.recipients.some((recipient) => recipient.signingStatus === SigningStatus.REJECTED) ||
     document.recipients.every((recipient) => recipient.signingStatus === SigningStatus.SIGNED);
@@ -129,22 +129,49 @@ export const run = async ({
     documentData.data = documentData.initialData;
   }
 
+  if (!document.qrToken) {
+    await prisma.document.update({
+      where: {
+        id: document.id,
+      },
+      data: {
+        qrToken: prefixedId('qr'),
+      },
+    });
+  }
+
   const pdfData = await getFileServerSide(documentData);
 
-  const certificateData =
-    (document.team?.teamGlobalSettings?.includeSigningCertificate ?? true)
-      ? await getCertificatePdf({
-          documentId,
-          language: document.documentMeta?.language,
-        }).catch(() => null)
-      : null;
+  const certificateData = settings.includeSigningCertificate
+    ? await getCertificatePdf({
+        documentId,
+        language: document.documentMeta?.language,
+      }).catch((e) => {
+        console.log('Failed to get certificate PDF');
+        console.error(e);
+
+        return null;
+      })
+    : null;
+
+  const auditLogData = settings.includeAuditLog
+    ? await getAuditLogsPdf({
+        documentId,
+        language: document.documentMeta?.language,
+      }).catch((e) => {
+        console.log('Failed to get audit logs PDF');
+        console.error(e);
+
+        return null;
+      })
+    : null;
 
   const newDataId = await io.runTask('decorate-and-sign-pdf', async () => {
     const pdfDoc = await PDFDocument.load(pdfData);
 
     // Normalize and flatten layers that could cause issues with the signature
     normalizeSignatureAppearances(pdfDoc);
-    flattenForm(pdfDoc);
+    await flattenForm(pdfDoc);
     flattenAnnotations(pdfDoc);
 
     // Add rejection stamp if the document is rejected
@@ -165,15 +192,27 @@ export const run = async ({
       });
     }
 
+    if (auditLogData) {
+      const auditLogDoc = await PDFDocument.load(auditLogData);
+
+      const auditLogPages = await pdfDoc.copyPages(auditLogDoc, auditLogDoc.getPageIndices());
+
+      auditLogPages.forEach((page) => {
+        pdfDoc.addPage(page);
+      });
+    }
+
     for (const field of fields) {
       if (field.inserted) {
-        await insertFieldInPDF(pdfDoc, field);
+        document.useLegacyFieldInsertion
+          ? await legacy_insertFieldInPDF(pdfDoc, field)
+          : await insertFieldInPDF(pdfDoc, field);
       }
     }
 
     // Re-flatten the form to handle our checkbox and radio fields that
     // create native arcoFields
-    flattenForm(pdfDoc);
+    await flattenForm(pdfDoc);
 
     const pdfBytes = await pdfDoc.save();
     const pdfBuffer = await signPdf({ pdf: Buffer.from(pdfBytes) });