@dereekb/nestjs 12.7.0 → 13.0.1

package/mailgun/index.esm.js

@@ -0,0 +1,626 @@
+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,27 @@
 {
   "name": "@dereekb/nestjs/mailgun",
-  "version": "12.7.0",
-  "type": "commonjs",
-  "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "version": "13.0.1",
+  "peerDependencies": {
+    "@dereekb/date": "13.0.1",
+    "@dereekb/model": "13.0.1",
+    "@dereekb/nestjs": "13.0.1",
+    "@dereekb/rxjs": "13.0.1",
+    "@dereekb/util": "13.0.1",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "form-data": "^4.0.0",
+    "mailgun.js": "^12.0.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
 }

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'];