@dereekb/nestjs 12.6.21 → 13.0.0

package/mailgun/index.esm.js

@@ -0,0 +1,633 @@
+import { isTestNodeEnv, ServerEnvironmentService } from '@dereekb/nestjs';
+import { MAP_IDENTITY, asArray, forEachKeyValue, objectIsEmpty, addToSet, overrideInObject, KeyValueTypleValueFilter, forEachInIterable, makeValuesGroupMap, filterMaybeArrayValues } from '@dereekb/util';
+import { Injectable, Inject, Module } from '@nestjs/common';
+import Mailgun from 'mailgun.js';
+import FormData from 'form-data';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+
+const DEFAULT_RECIPIENT_VARIABLE_PREFIX = 'recipient-';
+const MAILGUN_REPLY_TO_EMAIL_HEADER_DATA_VARIABLE_KEY = `h:Reply-To`;
+/**
+ * The maximum number of recipients allowed in a single batch send request.
+ */
+const MAX_BATCH_SEND_RECIPIENTS = 1000;
+/**
+ * Converts a MailgunTemplateEmailRequest to a MailgunMessageData.
+ *
+ * @param config
+ * @returns
+ */
+function convertMailgunTemplateEmailRequestToMailgunMessageData(config) {
+  const {
+    request,
+    defaultSender,
+    isTestingEnvironment: testEnvironment,
+    recipientVariablePrefix: inputRecipientVariablePrefix = DEFAULT_RECIPIENT_VARIABLE_PREFIX,
+    addRecipientVariablePrefixToAllMergedGlobalVariables: inputAddRecipientVariablePrefixToAllMergedGlobalVariables = true,
+    addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables: inputAddCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables = false,
+    addCopyOfTemplateVariablesWithRecipientVariablePrefix: inputAddCopyOfTemplateVariablesWithRecipientVariablePrefix = false
+  } = config;
+  const {
+    recipientVariablesConfig
+  } = request;
+  const recipientVariablePrefix = recipientVariablesConfig?.recipientVariablePrefix ?? inputRecipientVariablePrefix;
+  const addRecipientVariablePrefixToAllMergedGlobalVariables = recipientVariablesConfig?.addRecipientVariablePrefixToAllMergedGlobalVariables ?? inputAddRecipientVariablePrefixToAllMergedGlobalVariables;
+  const addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables = recipientVariablesConfig?.addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables ?? inputAddCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables;
+  const addCopyOfTemplateVariablesWithRecipientVariablePrefix = recipientVariablesConfig?.addCopyOfTemplateVariablesWithRecipientVariablePrefix ?? inputAddCopyOfTemplateVariablesWithRecipientVariablePrefix;
+  const finalizeRecipientVariables = request.finalizeRecipientVariables ?? MAP_IDENTITY;
+  const allowBatchSending = request.batchSend ?? true;
+  const mergeRecipientVariablesIntoGlobalVariable = !allowBatchSending;
+  function mapEmailToLowercase(x) {
+    return {
+      ...x,
+      email: x.email.toLowerCase()
+    };
+  }
+  const toInput = asArray(request.to).map(mapEmailToLowercase);
+  const ccInput = request.cc ? asArray(request.cc).map(mapEmailToLowercase) : undefined;
+  const bccInput = request.bcc ? asArray(request.bcc).map(mapEmailToLowercase) : undefined;
+  const from = request.from ? convertMailgunRecipientToString(request.from) : defaultSender;
+  const to = convertMailgunRecipientsToStrings(toInput);
+  const cc = ccInput?.length ? convertMailgunRecipientsToStrings(ccInput) : undefined;
+  const bcc = bccInput?.length ? convertMailgunRecipientsToStrings(bccInput) : undefined;
+  // throw an error if batchSend is not defined and cc or bcc is defined
+  if (request.batchSend == null && (ccInput || bccInput)) {
+    throw new Error('convertMailgunTemplateEmailRequestToMailgunMessageData(): batchSend must be false when either "cc" or "bcc" is defined.');
+  }
+  if (allowBatchSending && to.length > MAX_BATCH_SEND_RECIPIENTS) {
+    throw new Error(`convertMailgunTemplateEmailRequestToMailgunMessageData(): Can only batch send to a maximum of ${MAX_BATCH_SEND_RECIPIENTS} recipients.`);
+  }
+  const data = {
+    from,
+    to,
+    cc,
+    bcc,
+    subject: request.subject,
+    template: request.template,
+    ...request.messageData
+  };
+  if (request.replyTo != null) {
+    data[MAILGUN_REPLY_TO_EMAIL_HEADER_DATA_VARIABLE_KEY] = convertMailgunRecipientToString(request.replyTo);
+  }
+  if (request.testEmail === true || (testEnvironment ?? isTestNodeEnv()) && request.testEmail !== false) {
+    data['o:testmode'] = true;
+  }
+  if (request.templateVariables) {
+    forEachKeyValue(request.templateVariables, {
+      forEach: x => {
+        const [key, value] = x;
+        const encodedValue = encodeMailgunTemplateVariableValue(value);
+        if (encodedValue != null) {
+          data[`v:${key}`] = encodedValue;
+          if (recipientVariablePrefix && addCopyOfTemplateVariablesWithRecipientVariablePrefix) {
+            data[`v:${recipientVariablePrefix}${key}`] = encodedValue;
+          }
+        }
+      }
+    });
+  }
+  const hasUserVariables = Boolean(data['recipient-variables']) || toInput.findIndex(x => x.userVariables != null) !== -1;
+  if (hasUserVariables) {
+    let recipientVariables = {};
+    const allRecipientVariableKeys = new Set();
+    toInput.forEach(({
+      email,
+      userVariables
+    }) => {
+      if (userVariables != null && !objectIsEmpty(userVariables)) {
+        recipientVariables[email] = userVariables;
+        addToSet(allRecipientVariableKeys, Object.keys(userVariables));
+      }
+    });
+    if (data['recipient-variables']) {
+      const decoded = JSON.parse(data['recipient-variables']);
+      forEachKeyValue(decoded, {
+        forEach: x => {
+          const [recipientEmail, userVariables] = x;
+          const email = recipientEmail.toLowerCase();
+          if (recipientVariables[email] != null) {
+            overrideInObject(recipientVariables[email], {
+              from: [userVariables],
+              filter: {
+                valueFilter: KeyValueTypleValueFilter.UNDEFINED
+              }
+            });
+          } else {
+            recipientVariables[email] = userVariables;
+          }
+          addToSet(allRecipientVariableKeys, Object.keys(userVariables));
+        }
+      });
+    }
+    // Finalize the recipient variables before they are re-encoded back to JSON
+    recipientVariables = finalizeRecipientVariables(recipientVariables, {
+      messageData: data,
+      config
+    }) ?? recipientVariables;
+    if (mergeRecipientVariablesIntoGlobalVariable) {
+      const addRecipientPrefixVariable = recipientVariablePrefix && addRecipientVariablePrefixToAllMergedGlobalVariables;
+      // iterate all recipient variables and merge them into the global variables
+      forEachKeyValue(recipientVariables, {
+        forEach: x => {
+          const [email, userVariables] = x;
+          forEachKeyValue(userVariables, {
+            forEach: y => {
+              const [key, value] = y;
+              const encodedValue = encodeMailgunTemplateVariableValue(value);
+              if (encodedValue != null) {
+                if (addRecipientPrefixVariable) {
+                  // also add the variable using the recipient variable prefix
+                  const recipientVariableKey = `${recipientVariablePrefix}${key}`;
+                  data[`v:${recipientVariableKey}`] = encodedValue;
+                }
+                // add if not adding the prefix variable, or if it was requested
+                if (!addRecipientPrefixVariable || addCopyOfMergedRecipientVariablesWithoutPrefixToGlobalVariables) {
+                  data[`v:${key}`] = encodedValue;
+                }
+              }
+            }
+          });
+        }
+      });
+    } else {
+      // set back on the data object
+      data['recipient-variables'] = JSON.stringify(recipientVariables);
+      // add all recipient variable to the other variables so they can be used easily/directly in templates as variables too.
+      // https://documentation.mailgun.com/en/latest/user_manual.html#attaching-data-to-messages
+      if (recipientVariablePrefix) {
+        forEachInIterable(allRecipientVariableKeys, key => {
+          const recipientVariableKey = `${recipientVariablePrefix}${key}`;
+          // v:recipient-id=%recipient.id%
+          data[`v:${recipientVariableKey}`] = `%recipient.${key}%`;
+        });
+      }
+    }
+  }
+  // double check and remove the recipient variables if we merged them into the global variables
+  if (mergeRecipientVariablesIntoGlobalVariable) {
+    delete data['recipient-variables'];
+  }
+  const inputAttachments = request.attachments;
+  if (inputAttachments) {
+    if (data.attachment) {
+      throw new Error(`Cannot specify attachments in both messageData and in the request's attachments field.`);
+    }
+    data.attachment = inputAttachments;
+  }
+  return data;
+}
+function convertMailgunRecipientsToStrings(recipients) {
+  return recipients.map(x => convertMailgunRecipientToString(x));
+}
+function convertMailgunRecipientToString(recipient) {
+  let address = recipient.email;
+  if (recipient.name) {
+    address = `${recipient.name} <${address}>`;
+  }
+  return address;
+}
+/**
+ * Encodes a value to a string for use as a Mailgun template variable. Throws an error if the value is not supported.
+ *
+ * @param value The value to encode.
+ * @returns The encoded value, or undefined if the value is null or undefined.
+ */
+function encodeMailgunTemplateVariableValue(value) {
+  let encodedValue;
+  switch (typeof value) {
+    case 'object':
+      if (value) {
+        if (value instanceof Date) {
+          encodedValue = value.toISOString();
+        } else {
+          encodedValue = JSON.stringify(value);
+        }
+      }
+      break;
+    case 'bigint':
+    case 'boolean':
+    case 'number':
+    case 'string':
+      encodedValue = String(value); // encoded as a string value
+      break;
+    default:
+      if (value) {
+        throw new Error(`Invalid value "${value}" passed to encodeMailgunTemplateVariableValue().`);
+      }
+  }
+  return encodedValue;
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class MailgunServiceConfig {
+  // Mailgun Config
+  mailgun;
+  /**
+   * Base URL to the client.
+   */
+  clientUrl;
+  /**
+   * Main domain to send emails from.
+   */
+  domain;
+  /**
+   * Mailgun sender string.
+   */
+  sender;
+  /**
+   * Additional messages config
+   */
+  messages;
+  static assertValidConfig(config) {
+    if (!config.mailgun.username) {
+      throw new Error('No mailgun username specified.');
+    } else if (!config.mailgun.key) {
+      throw new Error('No mailgun key specified.');
+    } else if (!config.domain) {
+      throw new Error('No mailgun domain specified.');
+    } else if (!config.clientUrl) {
+      throw new Error('No client url specified.');
+    } else if (!config.sender) {
+      throw new Error('No mailgun sender specified.');
+    } else if (!config.messages) {
+      throw new Error('No mailgun messages config specified.');
+    }
+  }
+}
+
+let MailgunApi = class MailgunApi {
+  config;
+  client;
+  constructor(config) {
+    this.config = config;
+    this.client = new Mailgun(FormData).client({
+      ...config.mailgun
+    });
+  }
+  get messages() {
+    return this.client.messages;
+  }
+  get clientUrl() {
+    return this.config.clientUrl;
+  }
+  get domain() {
+    return this.config.domain;
+  }
+  get sender() {
+    return this.config.sender;
+  }
+};
+MailgunApi = __decorate([Injectable(), __param(0, Inject(MailgunServiceConfig)), __metadata("design:paramtypes", [MailgunServiceConfig])], MailgunApi);
+
+let MailgunService = class MailgunService {
+  _mailgunApi;
+  _serverEnvironmentService;
+  constructor(mailgunApi, serverEnvironmentService) {
+    this._mailgunApi = mailgunApi;
+    this._serverEnvironmentService = serverEnvironmentService;
+  }
+  get mailgunApi() {
+    return this._mailgunApi;
+  }
+  get serverEnvironmentService() {
+    return this._serverEnvironmentService;
+  }
+  async sendTemplateEmail(request) {
+    const domain = this.mailgunApi.domain;
+    const sender = this.mailgunApi.sender;
+    const isTestingEnvironment = this.serverEnvironmentService.isTestingEnv;
+    const {
+      recipientVariablePrefix
+    } = this.mailgunApi.config.messages;
+    const data = convertMailgunTemplateEmailRequestToMailgunMessageData({
+      request,
+      defaultSender: sender,
+      recipientVariablePrefix,
+      isTestingEnvironment
+    });
+    let result;
+    const shouldSend = !isTestingEnvironment || request.sendTestEmails || this.mailgunApi.config.messages.sendTestEmails;
+    if (shouldSend) {
+      try {
+        result = await this.mailgunApi.messages.create(domain, data);
+      } catch (e) {
+        console.error('Failed sending email: ', e);
+        throw e;
+      }
+    } else {
+      result = {
+        status: 200,
+        message: 'Success. Env prevented sending email.'
+      };
+    }
+    return result;
+  }
+};
+MailgunService = __decorate([Injectable(), __param(0, Inject(MailgunApi)), __param(1, Inject(ServerEnvironmentService)), __metadata("design:paramtypes", [MailgunApi, ServerEnvironmentService])], MailgunService);
+
+function mailgunServiceConfigFactory(configService, serverEnvironmentService) {
+  const isTestingEnv = serverEnvironmentService.isTestingEnv;
+  const useSandbox = configService.get('USE_MAILGUN_SANDBOX') === 'true' || isTestingEnv;
+  const sendTestEmails = configService.get('MAILGUN_SEND_TEST_EMAILS') === 'true';
+  let key = configService.get('MAILGUN_API_KEY');
+  let domain = configService.get('MAILGUN_DOMAIN');
+  if (useSandbox) {
+    key = configService.get('MAILGUN_SANDBOX_API_KEY');
+    domain = configService.get('MAILGUN_SANDBOX_DOMAIN');
+    if (!key || !domain) {
+      throw new Error('USE_MAILGUN_SANDBOX is set to "true" (or current environment is a testing environment), but no environment variables for the sandbox (MAILGUN_SANDBOX_API_KEY, MAILGUN_SANDBOX_DOMAIN) are provided.');
+    } else if (!serverEnvironmentService.isTestingEnv) {
+      console.log('Using Mailgun Sandbox Domain: ', domain);
+    }
+  } else if (!serverEnvironmentService.isTestingEnv) {
+    console.log('Using Mailgun Production Domain: ', domain);
+  }
+  const name = configService.get('MAILGUN_SENDER_NAME');
+  const email = configService.get('MAILGUN_SENDER_EMAIL');
+  const url = configService.get('MAILGUN_API_URL');
+  const recipientVariablePrefix = configService.get('MAILGUN_MESSAGES_RECIPIENT_VARIABLE_PREFIX') ?? undefined;
+  if (!email) {
+    throw new Error('MAILGUN_SENDER_EMAIL is required but was not configured.');
+  } else if (!key) {
+    throw new Error('MAILGUN_API_KEY (or MAILGUN_SANDBOX_API_KEY for tests) is required but was not configured.');
+  } else if (!domain) {
+    throw new Error('MAILGUN_DOMAIN (or MAILGUN_SANDBOX_DOMAIN for tests) is required but was not configured.');
+  }
+  const clientUrl = configService.get('CLIENT_APP_URL') ?? domain;
+  const config = {
+    mailgun: {
+      username: configService.get('MAILGUN_USERNAME') ?? 'api',
+      key,
+      url
+    },
+    domain,
+    clientUrl,
+    sender: convertMailgunRecipientToString({
+      name,
+      email
+    }),
+    messages: {
+      sendTestEmails,
+      recipientVariablePrefix
+    }
+  };
+  MailgunServiceConfig.assertValidConfig(config);
+  return config;
+}
+let MailgunServiceModule = class MailgunServiceModule {};
+MailgunServiceModule = __decorate([Module({
+  imports: [ConfigModule],
+  providers: [{
+    provide: MailgunServiceConfig,
+    inject: [ConfigService, ServerEnvironmentService],
+    useFactory: mailgunServiceConfigFactory
+  }, MailgunApi, MailgunService],
+  exports: [MailgunApi, MailgunService]
+})], MailgunServiceModule);
+
+/**
+ * The default template subject to use when batch sending emails.
+ *
+ * This pulls the subject from each recipient's user variables.
+ */
+const MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE = `%recipient.subject%`;
+/**
+ * Creates a composite key from the from/replyTo email addresses used to group MailgunRecipientBatchSendTarget values.
+ */
+function mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey(recipient) {
+  const fromEmail = (recipient.from?.email ?? '').toLowerCase();
+  const replyToEmail = (recipient.replyTo?.email ?? '').toLowerCase();
+  return `f:${fromEmail}|r:${replyToEmail}`;
+}
+/**
+ * Creates a ExpandMailgunRecipientBatchSendTargetRequestFactory from the input config.
+ *
+ * @param config
+ * @returns
+ */
+function expandMailgunRecipientBatchSendTargetRequestFactory(config) {
+  const {
+    request: inputBaseRequest,
+    useSubjectFromRecipientUserVariables,
+    allowSingleRecipientBatchSendRequests,
+    recipientVariablesConfig,
+    mailgunRecipientBatchSendTargetEntityKeyRecipientLookup,
+    overrideCarbonCopyVariablesWithCarbonCopyKeyRecipients
+  } = config;
+  const defaultSubject = inputBaseRequest.subject;
+  if (!defaultSubject && !useSubjectFromRecipientUserVariables) {
+    throw new Error('defaultSubject must be set when "useSubjectFromRecipientUserVariables" is false');
+  }
+  /**
+   * Returns the carbon copy recipients, based on the input.
+   *
+   * Will return undefined if the array would be empty.
+   *
+   * @param input
+   * @returns
+   */
+  function determineCarbonCopyRecipients(input) {
+    const {
+      baseRequestCarbonCopyRecipients,
+      carbonCopyRecipients,
+      carbonCopyRecipientsKeys
+    } = input;
+    let cc = carbonCopyRecipients ? asArray(carbonCopyRecipients) : baseRequestCarbonCopyRecipients;
+    const resolvedCc = mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?.getRecipientsForKeys(carbonCopyRecipientsKeys);
+    if (resolvedCc?.length) {
+      if (overrideCarbonCopyVariablesWithCarbonCopyKeyRecipients) {
+        cc = resolvedCc;
+      } else {
+        cc = [...(cc ?? []), ...resolvedCc];
+      }
+    }
+    return cc?.length ? cc : undefined;
+  }
+  const baseRequestCc = determineCarbonCopyRecipients({
+    carbonCopyRecipients: inputBaseRequest.cc,
+    carbonCopyRecipientsKeys: inputBaseRequest.ccKeys
+  });
+  const baseRequestBcc = determineCarbonCopyRecipients({
+    carbonCopyRecipients: inputBaseRequest.bcc,
+    carbonCopyRecipientsKeys: inputBaseRequest.bccKeys
+  });
+  const baseRequestFrom = inputBaseRequest.from ?? mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?.getRecipientOrDefaultForKey(inputBaseRequest.fromKey);
+  const baseRequestReplyTo = inputBaseRequest.replyTo ?? mailgunRecipientBatchSendTargetEntityKeyRecipientLookup?.getRecipientOrDefaultForKey(inputBaseRequest.replyToKey);
+  const baseRequest = {
+    ...inputBaseRequest,
+    from: baseRequestFrom,
+    replyTo: baseRequestReplyTo,
+    cc: baseRequestCc,
+    bcc: baseRequestBcc
+  };
+  delete baseRequest.fromKey;
+  delete baseRequest.replyToKey;
+  delete baseRequest.ccKeys;
+  delete baseRequest.bccKeys;
+  const configAllowBatchSend = baseRequest.batchSend !== false;
+  return inputRecipients => {
+    // Process recipients to resolve keys
+    const recipients = inputRecipients.map(recipient => {
+      let from = recipient.from;
+      let replyTo = recipient.replyTo;
+      if (mailgunRecipientBatchSendTargetEntityKeyRecipientLookup) {
+        // try the fromKey, otherwise use the baseRequest.from
+        if (!from) {
+          from = mailgunRecipientBatchSendTargetEntityKeyRecipientLookup.getRecipientOrDefaultForKey(recipient.fromKey, baseRequest.from);
+        }
+        // try the replyToKey, otherwise use the baseRequest.replyTo
+        if (!replyTo) {
+          replyTo = mailgunRecipientBatchSendTargetEntityKeyRecipientLookup.getRecipientOrDefaultForKey(recipient.replyToKey, baseRequest.replyTo);
+        }
+      } else {
+        // use defaults from base request
+        if (!from) {
+          from = baseRequest.from;
+        }
+        if (!replyTo) {
+          replyTo = baseRequest.replyTo;
+        }
+      }
+      const cc = determineCarbonCopyRecipients({
+        baseRequestCarbonCopyRecipients: baseRequestCc,
+        carbonCopyRecipients: recipient.cc,
+        carbonCopyRecipientsKeys: recipient.ccKeys
+      });
+      const bcc = determineCarbonCopyRecipients({
+        baseRequestCarbonCopyRecipients: baseRequestBcc,
+        carbonCopyRecipients: recipient.bcc,
+        carbonCopyRecipientsKeys: recipient.bccKeys
+      });
+      const result = {
+        ...recipient,
+        from,
+        replyTo,
+        cc,
+        bcc
+      };
+      return result;
+    });
+    const allowBatchSend = configAllowBatchSend && (allowSingleRecipientBatchSendRequests || recipients.length > 1);
+    const nonBatchSendRequests = [];
+    const batchSendRequestRecipients = [];
+    recipients.forEach(recipient => {
+      const recipientHasCarbonCopy = Boolean(recipient.cc?.length || recipient.bcc?.length);
+      if (allowBatchSend && !recipientHasCarbonCopy) {
+        // add to batch send recipients
+        batchSendRequestRecipients.push(recipient);
+      } else {
+        // add to non-batch send requests
+        // use the subject from the recipient's user variables if available as a default
+        const cc = recipient.cc;
+        const bcc = recipient.bcc;
+        const subject = (useSubjectFromRecipientUserVariables ? recipient.userVariables?.['subject'] : undefined) ?? defaultSubject ?? recipient.userVariables?.['subject'];
+        const request = {
+          ...baseRequest,
+          from: recipient.from ?? baseRequest.from,
+          replyTo: recipient.replyTo ?? baseRequest.replyTo,
+          recipientVariablesConfig: baseRequest.recipientVariablesConfig ?? recipientVariablesConfig,
+          to: recipient,
+          cc,
+          bcc,
+          subject,
+          batchSend: false // explicitly disable batch send for non-batch requests
+        };
+        nonBatchSendRequests.push(request);
+      }
+    });
+    // create batch send request(s)
+    const batchSendRequests = [];
+    if (batchSendRequestRecipients.length > 0) {
+      const subject = useSubjectFromRecipientUserVariables ? MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE : defaultSubject;
+      // Group recipients by their from/replyTo values
+      const batchSendRecipientGroups = makeValuesGroupMap(batchSendRequestRecipients, mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey);
+      batchSendRecipientGroups.forEach(groupRecipients => {
+        // All recipients in this group should share the same from/replyTo values
+        const firstRecipient = groupRecipients[0];
+        const batchRequest = {
+          ...baseRequest,
+          from: firstRecipient.from,
+          replyTo: firstRecipient.replyTo,
+          recipientVariablesConfig: baseRequest.recipientVariablesConfig ?? recipientVariablesConfig,
+          to: groupRecipients,
+          subject,
+          batchSend: true
+        };
+        batchSendRequests.push(batchRequest);
+      });
+    }
+    return filterMaybeArrayValues([...batchSendRequests, ...nonBatchSendRequests]);
+  };
+}
+/**
+ * Creates a MailgunRecipientBatchSendTargetEntityKeyRecipientLookup given the input configuration.
+ *
+ * @param config The configuration for the lookup.
+ * @returns The lookup.
+ */
+function mailgunRecipientBatchSendTargetEntityKeyRecipientLookup(config) {
+  const {
+    recipientsMap
+  } = config;
+  function getRecipientOrDefaultForKey(input, defaultRecipient) {
+    let result = defaultRecipient;
+    if (input) {
+      result = recipientsMap.get(input) ?? defaultRecipient;
+    }
+    return result;
+  }
+  function getRecipientsForKeys(input) {
+    let result = undefined;
+    if (input) {
+      const keysArray = asArray(input);
+      const recipients = filterMaybeArrayValues(keysArray.map(key => recipientsMap.get(key)));
+      if (recipients.length > 0) {
+        result = recipients;
+      }
+    }
+    return result;
+  }
+  return {
+    recipientsMap,
+    getRecipientOrDefaultForKey,
+    getRecipientsForKeys
+  };
+}
+
+export { DEFAULT_RECIPIENT_VARIABLE_PREFIX, MAILGUN_BATCH_SEND_RECIPIENT_SUBJECT_TEMPLATE, MAILGUN_REPLY_TO_EMAIL_HEADER_DATA_VARIABLE_KEY, MAX_BATCH_SEND_RECIPIENTS, MailgunApi, MailgunService, MailgunServiceModule, convertMailgunRecipientToString, convertMailgunRecipientsToStrings, convertMailgunTemplateEmailRequestToMailgunMessageData, encodeMailgunTemplateVariableValue, expandMailgunRecipientBatchSendTargetRequestFactory, mailgunRecipientBatchSendTargetEntityKeyRecipientLookup, mailgunRecipientBatchSendTargetFromReplyToBatchGroupKey, mailgunServiceConfigFactory };

package/mailgun/package.json

@@ -1,7 +1,28 @@
 {
   "name": "@dereekb/nestjs/mailgun",
-  "version": "12.6.21",
-  "type": "commonjs",
+  "version": "13.0.0",
   "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "node": {
+        "require": "./index.cjs.js"
+      },
+      "browser": {
+        "require": "./index.cjs.js",
+        "import": "./index.esm.js"
+      },
+      "default": "./index.cjs.js"
+    }
+  },
+  "peerDependencies": {
+    "@dereekb/date": "13.0.0",
+    "@dereekb/nestjs": "13.0.0",
+    "@dereekb/model": "13.0.0",
+    "@dereekb/rxjs": "13.0.0",
+    "@dereekb/util": "13.0.0",
+    "core-js": "^3.0.0"
+  }
 }

package/mailgun/src/lib/mailgun.d.ts

@@ -1,6 +1,6 @@
 import { type ArrayOrValue, type EmailAddress, type EmailAddressDomain, type NameEmailPair, type EmailParticipantString, type Maybe } from '@dereekb/util';
-import { type APIResponse } from 'mailgun.js/Types/Common/ApiResponse';
-import { type CustomFileData, type MailgunMessageData, type MessagesSendResult } from 'mailgun.js/Types/Messages/Messages';
+import { type CustomFileData, type MailgunMessageData, type MessagesSendResult } from 'node_modules/mailgun.js/Types/Types/Messages/Messages';
+import { type APIResponse } from 'node_modules/mailgun.js/Types/Types/Common/ApiResponse';
 export type MailgunSenderDomainString = EmailAddressDomain;
 export type MailgunTemplateKey = string;
 /**

package/mailgun/src/lib/mailgun.type.d.ts

@@ -1,5 +1,5 @@
 import type Mailgun from 'mailgun.js';
-import { type MailgunClientOptions } from 'mailgun.js/Types/MailgunClient/MailgunClientOptions';
+import { type MailgunClientOptions } from 'node_modules/mailgun.js/Types/Types/MailgunClient/MailgunClientOptions';
 export type MailgunOptions = MailgunClientOptions;
 export type MailgunClient = ReturnType<Mailgun['client']>;
 export type MailgunMessagesClient = ReturnType<Mailgun['client']>['messages'];