@erxes/api-shared 0.0.0-stage → 3.2.19-1

package/src/utils/email/providers/sendgrid.ts

@@ -0,0 +1,280 @@
+import fetch from 'node-fetch';
+import { toBase64Attachments } from '../attachments';
+import { SENDGRID_API_BASE_URL } from '../constants';
+import {
+  EmailProviderConfigError,
+  EmailProviderRequestError,
+  IDnsRecord,
+  IEmailProvider,
+  IEmailProviderConfig,
+  IOutboundEmail,
+  ISender,
+  ISentEmail,
+  ISingleSenderInput,
+  TEmailProviderName,
+} from '../types';
+
+const REQUEST_TIMEOUT_MS = 15000;
+
+type TSendgridDnsEntry = {
+  host: string;
+  type: string;
+  data: string;
+  valid: boolean;
+};
+
+type TSendgridDomain = {
+  id: number;
+  domain: string;
+  valid: boolean;
+  dns?: Record<string, TSendgridDnsEntry>;
+};
+
+type TSendgridVerifiedSender = {
+  id: number;
+  nickname?: string;
+  from_email: string;
+  from_name?: string;
+  verified: boolean;
+};
+
+const toDnsRecords = (dns?: Record<string, TSendgridDnsEntry>): IDnsRecord[] =>
+  Object.values(dns || {}).map((entry) => ({
+    type: entry.type.toUpperCase() as IDnsRecord['type'],
+    host: entry.host,
+    data: entry.data,
+    valid: entry.valid,
+  }));
+
+const toSingleSender = (sender: TSendgridVerifiedSender): ISender => ({
+  id: String(sender.id),
+  type: 'single',
+  value: sender.from_email,
+  name: sender.from_name || sender.nickname,
+  status: sender.verified ? 'verified' : 'pending',
+});
+
+const toDomainSender = (domain: TSendgridDomain): ISender => ({
+  id: String(domain.id),
+  type: 'domain',
+  value: domain.domain,
+  status: domain.valid ? 'verified' : 'pending',
+  dnsRecords: toDnsRecords(domain.dns),
+});
+
+const toSendError = (error: any) => {
+  const response = error?.response;
+
+  if (!response) {
+    return error;
+  }
+
+  return new EmailProviderRequestError(
+    'sendgrid',
+    response.statusCode || 0,
+    typeof response.body === 'string'
+      ? response.body
+      : JSON.stringify(response.body),
+  );
+};
+
+export class SendgridEmailProvider implements IEmailProvider {
+  public readonly name: TEmailProviderName = 'sendgrid';
+
+  private apiKey: string;
+  private subuser?: string;
+  private mailer: any;
+
+  constructor(config: IEmailProviderConfig) {
+    if (!config.SENDGRID_API_KEY) {
+      throw new EmailProviderConfigError('sendgrid', ['SENDGRID_API_KEY']);
+    }
+
+    this.apiKey = config.SENDGRID_API_KEY;
+    this.subuser = config.SENDGRID_SUBUSER;
+
+    const { MailService } = require('@sendgrid/mail');
+
+    const mailer = new MailService();
+
+    mailer.setApiKey(this.apiKey);
+
+    this.mailer = mailer;
+  }
+
+  public async send(message: IOutboundEmail): Promise<ISentEmail> {
+    const attachments = message.attachments?.length
+      ? await toBase64Attachments(message.attachments)
+      : undefined;
+
+    const payload: Record<string, unknown> = {
+      from: message.from,
+      to: message.to,
+      cc: message.cc?.length ? message.cc : undefined,
+      bcc: message.bcc?.length ? message.bcc : undefined,
+      replyTo: message.replyTo,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments,
+      headers: message.headers,
+      customArgs: message.customArgs,
+    };
+
+    let response: any;
+
+    try {
+      [response] = await this.mailer.send(payload);
+    } catch (error) {
+      throw toSendError(error);
+    }
+
+    const messageId =
+      response?.headers?.['x-message-id'] ||
+      response?.headers?.['X-Message-Id'] ||
+      '';
+
+    return {
+      messageId: String(messageId),
+      provider: this.name,
+      accepted: message.to,
+      rejected: [],
+    };
+  }
+
+  public async listSingleSenders(ids?: string[]): Promise<ISender[]> {
+    const paths = ids?.length
+      ? ids.map((id) => `/verified_senders?id=${encodeURIComponent(id)}`)
+      : ['/verified_senders'];
+
+    const pages = await Promise.all(
+      paths.map((path) =>
+        this.request<{ results?: TSendgridVerifiedSender[] }>('GET', path),
+      ),
+    );
+
+    return pages.flatMap((page) => (page?.results || []).map(toSingleSender));
+  }
+
+  public async listAuthenticatedDomains(
+    domains?: string[],
+  ): Promise<ISender[]> {
+    const paths = domains?.length
+      ? domains.map(
+          (domain) =>
+            `/whitelabel/domains?domain=${encodeURIComponent(domain)}`,
+        )
+      : ['/whitelabel/domains'];
+
+    const pages = await Promise.all(
+      paths.map((path) => this.request<TSendgridDomain[]>('GET', path)),
+    );
+
+    return pages.flatMap((page) => (page || []).map(toDomainSender));
+  }
+
+  public async verifySingleSender(input: ISingleSenderInput): Promise<ISender> {
+    const created = await this.request<TSendgridVerifiedSender>(
+      'POST',
+      '/verified_senders',
+      {
+        nickname: input.name || input.email,
+        from_email: input.email,
+        from_name: input.name || input.email,
+        reply_to: input.replyTo || input.email,
+        address: input.address || '',
+        city: input.city || '',
+        country: input.country || '',
+      },
+    );
+
+    return {
+      id: String(created.id),
+      type: 'single',
+      value: created.from_email,
+      name: created.from_name,
+      status: created.verified ? 'verified' : 'pending',
+    };
+  }
+
+  public async removeSender(id: string): Promise<void> {
+    await this.request('DELETE', `/verified_senders/${encodeURIComponent(id)}`);
+  }
+
+  public async authenticateDomain(domain: string): Promise<ISender> {
+    const created = await this.request<TSendgridDomain>(
+      'POST',
+      '/whitelabel/domains',
+      {
+        domain,
+        automatic_security: true,
+      },
+    );
+
+    return toDomainSender(created);
+  }
+
+  public async validateDomain(id: string): Promise<ISender> {
+    const encodedId = encodeURIComponent(id);
+
+    await this.request('POST', `/whitelabel/domains/${encodedId}/validate`);
+
+    const domain = await this.request<TSendgridDomain>(
+      'GET',
+      `/whitelabel/domains/${encodedId}`,
+    );
+
+    return toDomainSender(domain);
+  }
+
+  private async request<TResponse = unknown>(
+    method: 'GET' | 'POST' | 'DELETE',
+    path: string,
+    body?: unknown,
+  ): Promise<TResponse> {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+
+    if (this.subuser) {
+      headers['on-behalf-of'] = this.subuser;
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+    let response;
+
+    try {
+      response = await fetch(`${SENDGRID_API_BASE_URL}${path}`, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+
+    if (!response.ok) {
+      throw new EmailProviderRequestError(
+        'sendgrid',
+        response.status,
+        await response.text(),
+      );
+    }
+
+    if (response.status === 204) {
+      return undefined as TResponse;
+    }
+
+    const text = await response.text();
+
+    if (!text) {
+      return undefined as TResponse;
+    }
+
+    return JSON.parse(text) as TResponse;
+  }
+}

package/src/utils/email/providers/sendgridEvents.ts

@@ -0,0 +1,48 @@
+import * as crypto from 'crypto';
+
+export const SENDGRID_SIGNATURE_HEADER =
+  'x-twilio-email-event-webhook-signature';
+export const SENDGRID_TIMESTAMP_HEADER =
+  'x-twilio-email-event-webhook-timestamp';
+
+export interface ISendgridEvent {
+  email?: string;
+  event?: string;
+  timestamp?: number;
+  sg_message_id?: string;
+  reason?: string;
+  type?: string;
+  [customArg: string]: unknown;
+}
+
+export const verifySendgridSignature = ({
+  publicKey,
+  signature,
+  timestamp,
+  payload,
+}: {
+  publicKey: string;
+  signature: string;
+  timestamp: string;
+  payload: Buffer | string;
+}): boolean => {
+  if (!publicKey || !signature || !timestamp) {
+    return false;
+  }
+
+  try {
+    const key = crypto.createPublicKey({
+      key: Buffer.from(publicKey, 'base64'),
+      format: 'der',
+      type: 'spki',
+    });
+
+    return crypto
+      .createVerify('sha256')
+      .update(timestamp)
+      .update(payload)
+      .verify(key, signature, 'base64');
+  } catch {
+    return false;
+  }
+};

package/src/utils/email/providers/ses.ts

@@ -0,0 +1,250 @@
+import * as AWS from 'aws-sdk';
+import * as nodemailer from 'nodemailer';
+import { SES_DKIM_CNAME_SUFFIX } from '../constants';
+import {
+  EmailProviderConfigError,
+  IDnsRecord,
+  IEmailProvider,
+  IEmailProviderConfig,
+  IOutboundEmail,
+  ISender,
+  ISentEmail,
+  ISingleSenderInput,
+  TEmailProviderName,
+  TSenderStatus,
+} from '../types';
+
+const toSenderStatus = (verificationStatus?: string): TSenderStatus => {
+  if (verificationStatus === 'Success') {
+    return 'verified';
+  }
+
+  if (
+    verificationStatus === 'Failed' ||
+    verificationStatus === 'TemporaryFailure'
+  ) {
+    return 'failed';
+  }
+
+  return 'pending';
+};
+
+export class SesEmailProvider implements IEmailProvider {
+  public readonly name: TEmailProviderName = 'SES';
+
+  private client: AWS.SES;
+  private configSet?: string;
+  private transporter: nodemailer.Transporter;
+
+  constructor(config: IEmailProviderConfig) {
+    const missing: string[] = [];
+
+    if (!config.AWS_SES_ACCESS_KEY_ID) {
+      missing.push('AWS_SES_ACCESS_KEY_ID');
+    }
+
+    if (!config.AWS_SES_SECRET_ACCESS_KEY) {
+      missing.push('AWS_SES_SECRET_ACCESS_KEY');
+    }
+
+    if (!config.AWS_REGION) {
+      missing.push('AWS_REGION');
+    }
+
+    if (missing.length) {
+      throw new EmailProviderConfigError('SES', missing);
+    }
+
+    this.configSet = config.AWS_SES_CONFIG_SET;
+
+    this.client = new AWS.SES({
+      apiVersion: '2010-12-01',
+      region: config.AWS_REGION,
+      accessKeyId: config.AWS_SES_ACCESS_KEY_ID,
+      secretAccessKey: config.AWS_SES_SECRET_ACCESS_KEY,
+    });
+
+    this.transporter = nodemailer.createTransport({
+      SES: this.client,
+    } as nodemailer.TransportOptions);
+  }
+
+  public async send(message: IOutboundEmail): Promise<ISentEmail> {
+    const headers: Record<string, string> = {
+      ...(this.configSet ? { 'X-SES-CONFIGURATION-SET': this.configSet } : {}),
+      ...(message.headers || {}),
+    };
+
+    for (const [key, value] of Object.entries(message.customArgs || {})) {
+      headers[key] = value;
+    }
+
+    const info = await this.transporter.sendMail({
+      from: message.from,
+      to: message.to.join(', '),
+      cc: message.cc?.length ? message.cc.join(', ') : undefined,
+      bcc: message.bcc?.length ? message.bcc.join(', ') : undefined,
+      replyTo: message.replyTo,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: message.attachments?.map((attachment) => ({
+        filename: attachment.filename,
+        path: attachment.path,
+        content: attachment.content
+          ? Buffer.from(attachment.content, 'base64')
+          : undefined,
+        contentType: attachment.contentType,
+      })),
+      headers,
+    });
+
+    return {
+      messageId: info.messageId,
+      provider: this.name,
+      accepted: (info.accepted || []).map(String),
+      rejected: (info.rejected || []).map(String),
+    };
+  }
+
+  public async listSingleSenders(ids?: string[]): Promise<ISender[]> {
+    const emails = ids ?? (await this.listAllIdentities('EmailAddress'));
+
+    if (!emails.length) {
+      return [];
+    }
+
+    const statuses = await this.getVerificationStatuses(emails);
+
+    return emails.map((email) => ({
+      id: email,
+      type: 'single' as const,
+      value: email,
+      status: toSenderStatus(statuses[email]),
+    }));
+  }
+
+  public async listAuthenticatedDomains(
+    domains?: string[],
+  ): Promise<ISender[]> {
+    const names = domains ?? (await this.listAllIdentities('Domain'));
+
+    return Promise.all(names.map((domain) => this.getDomainSender(domain)));
+  }
+
+  private async listAllIdentities(
+    identityType: 'EmailAddress' | 'Domain',
+  ): Promise<string[]> {
+    const identities: string[] = [];
+
+    let nextToken: string | undefined;
+
+    do {
+      const page = await this.client
+        .listIdentities({
+          IdentityType: identityType,
+          MaxItems: 100,
+          NextToken: nextToken,
+        })
+        .promise();
+
+      identities.push(...(page.Identities ?? []));
+
+      nextToken = page.NextToken;
+    } while (nextToken);
+
+    return identities;
+  }
+
+  private async getVerificationStatuses(
+    identities: string[],
+  ): Promise<Record<string, string | undefined>> {
+    const statuses: Record<string, string | undefined> = {};
+
+    for (let i = 0; i < identities.length; i += 100) {
+      const attributes = await this.client
+        .getIdentityVerificationAttributes({
+          Identities: identities.slice(i, i + 100),
+        })
+        .promise();
+
+      for (const [identity, attribute] of Object.entries(
+        attributes.VerificationAttributes ?? {},
+      )) {
+        statuses[identity] = attribute.VerificationStatus;
+      }
+    }
+
+    return statuses;
+  }
+
+  public async verifySingleSender(input: ISingleSenderInput): Promise<ISender> {
+    await this.client
+      .verifyEmailAddress({ EmailAddress: input.email })
+      .promise();
+
+    return {
+      id: input.email,
+      type: 'single',
+      value: input.email,
+      name: input.name,
+      status: 'pending',
+    };
+  }
+
+  public async removeSender(id: string): Promise<void> {
+    await this.client.deleteIdentity({ Identity: id }).promise();
+  }
+
+  public async authenticateDomain(domain: string): Promise<ISender> {
+    await this.client.verifyDomainIdentity({ Domain: domain }).promise();
+
+    const dkim = await this.client
+      .verifyDomainDkim({ Domain: domain })
+      .promise();
+
+    const dnsRecords: IDnsRecord[] = (dkim.DkimTokens || []).map((token) => ({
+      type: 'CNAME',
+      host: `${token}._domainkey.${domain}`,
+      data: `${token}.${SES_DKIM_CNAME_SUFFIX}`,
+      valid: false,
+    }));
+
+    return {
+      id: domain,
+      type: 'domain',
+      value: domain,
+      status: 'pending',
+      dnsRecords,
+    };
+  }
+
+  public async validateDomain(id: string): Promise<ISender> {
+    return this.getDomainSender(id);
+  }
+
+  private async getDomainSender(domain: string): Promise<ISender> {
+    const dkim = await this.client
+      .getIdentityDkimAttributes({ Identities: [domain] })
+      .promise();
+
+    const attributes = dkim.DkimAttributes?.[domain];
+
+    const dnsRecords: IDnsRecord[] = (attributes?.DkimTokens || []).map(
+      (token) => ({
+        type: 'CNAME' as const,
+        host: `${token}._domainkey.${domain}`,
+        data: `${token}.${SES_DKIM_CNAME_SUFFIX}`,
+        valid: attributes?.DkimVerificationStatus === 'Success',
+      }),
+    );
+
+    return {
+      id: domain,
+      type: 'domain',
+      value: domain,
+      status: toSenderStatus(attributes?.DkimVerificationStatus),
+      dnsRecords,
+    };
+  }
+}

package/src/utils/email/providers/smtp.ts

@@ -0,0 +1,99 @@
+import * as nodemailer from 'nodemailer';
+import {
+  EmailProviderNotSupportedError,
+  IEmailProvider,
+  IEmailProviderConfig,
+  IOutboundEmail,
+  ISender,
+  ISentEmail,
+  ISingleSenderInput,
+  TEmailProviderName,
+} from '../types';
+
+const CONNECTION_TIMEOUT_MS = 15000;
+const GREETING_TIMEOUT_MS = 15000;
+const SOCKET_TIMEOUT_MS = 30000;
+
+export class SmtpEmailProvider implements IEmailProvider {
+  public readonly name: TEmailProviderName = 'custom';
+
+  private transporter: nodemailer.Transporter;
+
+  constructor(config: IEmailProviderConfig) {
+    const auth =
+      config.MAIL_USER && config.MAIL_PASS
+        ? { user: config.MAIL_USER, pass: config.MAIL_PASS }
+        : undefined;
+
+    const port = config.MAIL_PORT ? Number(config.MAIL_PORT) : undefined;
+
+    this.transporter = nodemailer.createTransport({
+      service: config.MAIL_SERVICE,
+      host: config.MAIL_HOST,
+      port,
+      auth,
+      ...(auth && port !== 465 ? { requireTLS: true } : {}),
+      connectionTimeout: CONNECTION_TIMEOUT_MS,
+      greetingTimeout: GREETING_TIMEOUT_MS,
+      socketTimeout: SOCKET_TIMEOUT_MS,
+    });
+  }
+
+  public async send(message: IOutboundEmail): Promise<ISentEmail> {
+    const info = await this.transporter.sendMail({
+      from: message.from,
+      to: message.to.join(', '),
+      cc: message.cc?.length ? message.cc.join(', ') : undefined,
+      bcc: message.bcc?.length ? message.bcc.join(', ') : undefined,
+      replyTo: message.replyTo,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: message.attachments?.map((attachment) => ({
+        filename: attachment.filename,
+        path: attachment.path,
+        content: attachment.content
+          ? Buffer.from(attachment.content, 'base64')
+          : undefined,
+        contentType: attachment.contentType,
+      })),
+      headers: { ...(message.headers || {}), ...(message.customArgs || {}) },
+    });
+
+    return {
+      messageId: info.messageId,
+      provider: this.name,
+      accepted: (info.accepted || []).map(String),
+      rejected: (info.rejected || []).map(String),
+    };
+  }
+
+  public async listSingleSenders(): Promise<ISender[]> {
+    throw new EmailProviderNotSupportedError('custom', 'listSingleSenders');
+  }
+
+  public async listAuthenticatedDomains(): Promise<ISender[]> {
+    throw new EmailProviderNotSupportedError(
+      'custom',
+      'listAuthenticatedDomains',
+    );
+  }
+
+  public async verifySingleSender(
+    _input: ISingleSenderInput,
+  ): Promise<ISender> {
+    throw new EmailProviderNotSupportedError('custom', 'verifySingleSender');
+  }
+
+  public async removeSender(_id: string): Promise<void> {
+    throw new EmailProviderNotSupportedError('custom', 'removeSender');
+  }
+
+  public async authenticateDomain(_domain: string): Promise<ISender> {
+    throw new EmailProviderNotSupportedError('custom', 'authenticateDomain');
+  }
+
+  public async validateDomain(_id: string): Promise<ISender> {
+    throw new EmailProviderNotSupportedError('custom', 'validateDomain');
+  }
+}