feat: add email domains (#1895)

Implemented Email Domains which allows Platform/Enterprise customers to
send emails to recipients using their custom emails.

packages/lib/server-only/email/get-email-context.ts

@@ -1,16 +1,34 @@
 import type { BrandingSettings } from '@documenso/email/providers/branding';
 import { prisma } from '@documenso/prisma';
-import type { OrganisationType } from '@documenso/prisma/client';
-import { type OrganisationClaim, type OrganisationGlobalSettings } from '@documenso/prisma/client';
+import type {
+  DocumentMeta,
+  EmailDomain,
+  Organisation,
+  OrganisationEmail,
+  OrganisationType,
+} from '@documenso/prisma/client';
+import {
+  EmailDomainStatus,
+  type OrganisationClaim,
+  type OrganisationGlobalSettings,
+} from '@documenso/prisma/client';
 
+import { DOCUMENSO_INTERNAL_EMAIL } from '../../constants/email';
 import { AppError, AppErrorCode } from '../../errors/app-error';
 import {
   organisationGlobalSettingsToBranding,
   teamGlobalSettingsToBranding,
 } from '../../utils/team-global-settings-to-branding';
-import { getTeamSettings } from '../team/get-team-settings';
+import { extractDerivedTeamSettings } from '../../utils/teams';
 
-type GetEmailContextOptions = {
+type EmailMetaOption = Partial<Pick<DocumentMeta, 'emailId' | 'emailReplyTo' | 'language'>>;
+
+type BaseGetEmailContextOptions = {
+  /**
+   * The source to extract the email context from.
+   * - "Team" will use the team settings followed by the inherited organisation settings
+   * - "Organisation" will use the organisation settings
+   */
   source:
     | {
         type: 'team';
@@ -20,37 +38,112 @@ type GetEmailContextOptions = {
         type: 'organisation';
         organisationId: string;
       };
+
+  /**
+   * The email type being sent, used to determine what email sender and language to use.
+   * - INTERNAL: Emails to users, such as team invites, etc.
+   * - RECIPIENT: Emails to recipients, such as document sent, document signed, etc.
+   */
+  emailType: 'INTERNAL' | 'RECIPIENT';
 };
 
+type InternalGetEmailContextOptions = BaseGetEmailContextOptions & {
+  emailType: 'INTERNAL';
+  meta?: EmailMetaOption | null;
+};
+
+type RecipientGetEmailContextOptions = BaseGetEmailContextOptions & {
+  emailType: 'RECIPIENT';
+
+  /**
+   * Force meta options as a typesafe way to ensure developers don't forget to
+   * pass it in if it is available.
+   */
+  meta: EmailMetaOption | null;
+};
+
+type GetEmailContextOptions = InternalGetEmailContextOptions | RecipientGetEmailContextOptions;
+
 type EmailContextResponse = {
+  allowedEmails: OrganisationEmail[];
   branding: BrandingSettings;
   settings: Omit<OrganisationGlobalSettings, 'id'>;
   claims: OrganisationClaim;
   organisationType: OrganisationType;
+  senderEmail: {
+    name: string;
+    address: string;
+  };
+  replyToEmail: string | undefined;
+  emailLanguage: string;
 };
 
 export const getEmailContext = async (
   options: GetEmailContextOptions,
 ): Promise<EmailContextResponse> => {
-  const { source } = options;
+  const { source, meta } = options;
 
+  let emailContext: Omit<EmailContextResponse, 'senderEmail' | 'replyToEmail' | 'emailLanguage'>;
+
+  if (source.type === 'organisation') {
+    emailContext = await handleOrganisationEmailContext(source.organisationId);
+  } else {
+    emailContext = await handleTeamEmailContext(source.teamId);
+  }
+
+  const emailLanguage = meta?.language || emailContext.settings.documentLanguage;
+
+  // Immediate return for internal emails.
+  if (options.emailType === 'INTERNAL') {
+    return {
+      ...emailContext,
+      senderEmail: DOCUMENSO_INTERNAL_EMAIL,
+      replyToEmail: undefined,
+      emailLanguage, // Not sure if we want to use this for internal emails.
+    };
+  }
+
+  const replyToEmail = meta?.emailReplyTo || emailContext.settings.emailReplyTo || undefined;
+  const senderEmailId = meta?.emailId || emailContext.settings.emailId;
+
+  const foundSenderEmail = emailContext.allowedEmails.find((email) => email.id === senderEmailId);
+
+  // Reset the emailId to null if not found.
+  if (!foundSenderEmail) {
+    emailContext.settings.emailId = null;
+  }
+
+  const senderEmail = foundSenderEmail
+    ? {
+        name: foundSenderEmail.emailName,
+        address: foundSenderEmail.email,
+      }
+    : DOCUMENSO_INTERNAL_EMAIL;
+
+  return {
+    ...emailContext,
+    senderEmail,
+    replyToEmail,
+    emailLanguage,
+  };
+};
+
+const handleOrganisationEmailContext = async (organisationId: string) => {
   const organisation = await prisma.organisation.findFirst({
-    where:
-      source.type === 'organisation'
-        ? {
-            id: source.organisationId,
-          }
-        : {
-            teams: {
-              some: {
-                id: source.teamId,
-              },
-            },
-          },
+    where: {
+      id: organisationId,
+    },
     include: {
-      subscription: true,
       organisationClaim: true,
       organisationGlobalSettings: true,
+      emailDomains: {
+        omit: {
+          privateKey: true,
+        },
+        include: {
+          emails: true,
+        },
+      },
     },
   });
 
@@ -60,27 +153,64 @@ export const getEmailContext = async (
 
   const claims = organisation.organisationClaim;
 
-  if (source.type === 'organisation') {
-    return {
-      branding: organisationGlobalSettingsToBranding(
-        organisation.organisationGlobalSettings,
-        organisation.id,
-        claims.flags.hidePoweredBy ?? false,
-      ),
-      settings: organisation.organisationGlobalSettings,
-      claims,
-      organisationType: organisation.type,
-    };
-  }
-
-  const teamSettings = await getTeamSettings({
-    teamId: source.teamId,
-  });
+  const allowedEmails = getAllowedEmails(organisation);
 
   return {
+    allowedEmails,
+    branding: organisationGlobalSettingsToBranding(
+      organisation.organisationGlobalSettings,
+      organisation.id,
+      claims.flags.hidePoweredBy ?? false,
+    ),
+    settings: organisation.organisationGlobalSettings,
+    claims,
+    organisationType: organisation.type,
+  };
+};
+
+const handleTeamEmailContext = async (teamId: number) => {
+  const team = await prisma.team.findFirst({
+    where: {
+      id: teamId,
+    },
+    include: {
+      teamGlobalSettings: true,
+      organisation: {
+        include: {
+          organisationClaim: true,
+          organisationGlobalSettings: true,
+          emailDomains: {
+            omit: {
+              privateKey: true,
+            },
+            include: {
+              emails: true,
+            },
+          },
+        },
+      },
+    },
+  });
+
+  if (!team) {
+    throw new AppError(AppErrorCode.NOT_FOUND);
+  }
+
+  const organisation = team.organisation;
+  const claims = organisation.organisationClaim;
+
+  const allowedEmails = getAllowedEmails(organisation);
+
+  const teamSettings = extractDerivedTeamSettings(
+    organisation.organisationGlobalSettings,
+    team.teamGlobalSettings,
+  );
+
+  return {
+    allowedEmails,
     branding: teamGlobalSettingsToBranding(
       teamSettings,
-      source.teamId,
+      teamId,
       claims.flags.hidePoweredBy ?? false,
     ),
     settings: teamSettings,
@@ -88,3 +218,18 @@ export const getEmailContext = async (
     organisationType: organisation.type,
   };
 };
+
+const getAllowedEmails = (
+  organisation: Organisation & {
+    emailDomains: (Pick<EmailDomain, 'status'> & { emails: OrganisationEmail[] })[];
+    organisationClaim: OrganisationClaim;
+  },
+) => {
+  if (!organisation.organisationClaim.flags.emailDomains) {
+    return [];
+  }
+
+  return organisation.emailDomains
+    .filter((emailDomain) => emailDomain.status === EmailDomainStatus.ACTIVE)
+    .flatMap((emailDomain) => emailDomain.emails);
+};