@nocobase/plugin-workflow-mailer 2.2.20 → 2.2.21

package/dist/node_modules/nodemailer/dist/esm/sendmail-transport/index.d.ts

@@ -0,0 +1,69 @@
+import type { Logger } from '../shared/index.js';
+import type { MimeNodeEnvelope } from '../mime-node/index.js';
+import type MailMessage from '../mailer/mail-message.js';
+import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOptions } from '../mailer/index.js';
+/**
+ * Options for the Sendmail transport
+ */
+export interface SendmailTransportOptions extends TransportOptions {
+    /** Selects this transport in createTransport, the binary itself is set with `path` */
+    sendmail?: boolean | string | undefined;
+    /** Path to the sendmail binary, defaults to 'sendmail' */
+    path?: string | undefined;
+    /** Either 'windows' or 'unix', the line ending of the message piped to sendmail */
+    newline?: string | undefined;
+    /** Arguments for the sendmail binary, replaces the default '-f <sender>' */
+    args?: string[] | undefined;
+}
+/**
+ * The value the Sendmail transport hands to the send callback
+ */
+export interface SendmailSentMessageInfo extends SentMessageInfo {
+    /** The envelope the message was sent with */
+    envelope: MimeNodeEnvelope;
+    /** Message-ID value of the message */
+    messageId: string;
+    /** Always 'Messages queued for delivery' */
+    response: string;
+}
+/**
+ * Generates a Transport object for Sendmail
+ *
+ * Possible options can be the following:
+ *
+ *  * **path** optional path to sendmail binary
+ *  * **newline** either 'windows' or 'unix'
+ *  * **args** an array of arguments for the sendmail binary
+ *
+ * @constructor
+ * @param optional config parameter for Sendmail
+ */
+declare class SendmailTransport {
+    mailer: Mail<SendmailSentMessageInfo>;
+    options: SendmailTransportOptions;
+    name: string;
+    version: string;
+    path: string;
+    args: string[] | false;
+    logger: Logger;
+    winbreak: boolean;
+    constructor(options?: SendmailTransportOptions | string);
+    /**
+     * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
+     *
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail: MailMessage<SendmailSentMessageInfo>, done: (err: Error | null, info?: SendmailSentMessageInfo) => void): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `SendmailTransport.Options` style references keep working
+ */
+declare namespace SendmailTransport {
+    type Options = SendmailTransportOptions;
+    type MailOptions = SendMailOptions;
+    type SentMessageInfo = SendmailSentMessageInfo;
+}
+/** The same aliases as module level exports, for `import * as SendmailTransport` and `import SendmailTransport = require()` */
+export type { SendmailTransportOptions as Options, SendMailOptions as MailOptions, SendmailSentMessageInfo as SentMessageInfo };
+export default SendmailTransport;

package/dist/node_modules/nodemailer/{lib → dist/esm}/sendmail-transport/index.js

@@ -1,12 +1,9 @@
-'use strict';
-
-const { spawn } = require('child_process');
-const packageData = require('../../package.json');
-const shared = require('../shared');
-const errors = require('../errors');
-const LeWindows = require('../mime-node/le-windows');
-const LeUnix = require('../mime-node/le-unix');
-
+import { spawn } from 'node:child_process';
+import * as packageData from '../package-info.js';
+import * as shared from '../shared/index.js';
+import * as errors from '../errors.js';
+import LeWindows from '../mime-node/le-windows.js';
+import LeUnix from '../mime-node/le-unix.js';
 /**
  * Generates a Transport object for Sendmail
  *
@@ -17,30 +14,25 @@ const LeUnix = require('../mime-node/le-unix');
  *  * **args** an array of arguments for the sendmail binary
  *
  * @constructor
- * @param {Object} optional config parameter for Sendmail
+ * @param optional config parameter for Sendmail
  */
 class SendmailTransport {
     constructor(options) {
         options = options || {};
-
         // use a reference to spawn for mocking purposes
         this._spawn = spawn;
-
         this.options = options;
-
         this.name = 'Sendmail';
         this.version = packageData.version;
-
         this.path = 'sendmail';
         this.args = false;
-
         this.logger = shared.getLogger(this.options, {
             component: this.options.component || 'sendmail'
         });
-
         if (typeof options === 'string') {
             this.path = options;
-        } else if (typeof options === 'object') {
+        }
+        else if (typeof options === 'object') {
             if (options.path) {
                 this.path = options.path;
             }
@@ -48,24 +40,21 @@ class SendmailTransport {
                 this.args = options.args;
             }
         }
-
         this.winbreak = ['win', 'windows', 'dos', '\r\n'].includes((options.newline || '').toString().toLowerCase());
     }
-
     /**
      * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
      *
-     * @param {Object} emailMessage MailComposer object
-     * @param {Function} callback Callback function to run when the sending is completed
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
      */
     send(mail, done) {
-        // Sendmail strips this header line by itself
+        // Sendmail strips this header line by itself. send() runs after the message was
+        // compiled, so mail.message is set
         mail.message.keepBcc = true;
-
         const envelope = mail.message.getEnvelope();
         const messageId = mail.message.messageId();
         let returned;
-
         const hasInvalidAddresses = []
             .concat(envelope.from || [])
             .concat(envelope.to || [])
@@ -78,13 +67,11 @@ class SendmailTransport {
             err.code = errors.ESENDMAIL;
             return done(err);
         }
-
         // force -i to keep single dots
         const args = this.args
             ? ['-i'].concat(this.args).concat(envelope.to)
             : ['-i'].concat(envelope.from ? ['-f', envelope.from] : []).concat(envelope.to);
-
-        const callback = err => {
+        const callback = (err) => {
             if (returned) {
                 // ignore any additional responses, already done
                 return;
@@ -101,89 +88,59 @@ class SendmailTransport {
                 });
             }
         };
-
         let sendmail;
         try {
             sendmail = this._spawn(this.path, args);
-        } catch (E) {
-            this.logger.error(
-                {
-                    err: E,
-                    tnx: 'spawn',
-                    messageId
-                },
-                'Error occurred while spawning sendmail. %s',
-                E.message
-            );
+        }
+        catch (E) {
+            this.logger.error({
+                err: E,
+                tnx: 'spawn',
+                messageId
+            }, 'Error occurred while spawning sendmail. %s', E.message);
             return callback(E);
         }
-
         if (sendmail) {
             sendmail.on('error', err => {
-                this.logger.error(
-                    {
-                        err,
-                        tnx: 'spawn',
-                        messageId
-                    },
-                    'Error occurred when sending message %s. %s',
-                    messageId,
-                    err.message
-                );
+                this.logger.error({
+                    err,
+                    tnx: 'spawn',
+                    messageId
+                }, 'Error occurred when sending message %s. %s', messageId, err.message);
                 callback(err);
             });
-
             sendmail.once('exit', code => {
                 if (!code) {
                     return callback();
                 }
-                const err = new Error(
-                    code === 127 ? 'Sendmail command not found, process exited with code ' + code : 'Sendmail exited with code ' + code
-                );
+                const err = new Error(code === 127 ? 'Sendmail command not found, process exited with code ' + code : 'Sendmail exited with code ' + code);
                 err.code = errors.ESENDMAIL;
-
-                this.logger.error(
-                    {
-                        err,
-                        tnx: 'stdin',
-                        messageId
-                    },
-                    'Error sending message %s to sendmail. %s',
-                    messageId,
-                    err.message
-                );
+                this.logger.error({
+                    err,
+                    tnx: 'stdin',
+                    messageId
+                }, 'Error sending message %s to sendmail. %s', messageId, err.message);
                 callback(err);
             });
+            // the close listener is handed the exit code as its first argument, so a non-zero
+            // code reaching it before the exit listener did counts as the error value
             sendmail.once('close', callback);
-
             sendmail.stdin.on('error', err => {
-                this.logger.error(
-                    {
-                        err,
-                        tnx: 'stdin',
-                        messageId
-                    },
-                    'Error occurred when piping message %s to sendmail. %s',
-                    messageId,
-                    err.message
-                );
+                this.logger.error({
+                    err,
+                    tnx: 'stdin',
+                    messageId
+                }, 'Error occurred when piping message %s to sendmail. %s', messageId, err.message);
                 callback(err);
             });
-
             const recipients = [].concat(envelope.to || []);
             if (recipients.length > 3) {
                 recipients.push('...and ' + recipients.splice(2).length + ' more');
             }
-            this.logger.info(
-                {
-                    tnx: 'send',
-                    messageId
-                },
-                'Sending message %s to <%s>',
-                messageId,
-                recipients.join(', ')
-            );
-
+            this.logger.info({
+                tnx: 'send',
+                messageId
+            }, 'Sending message %s to <%s>', messageId, recipients.join(', '));
             const sourceStream = mail.message.createReadStream();
             let stream = sourceStream;
             if (this.options.newline) {
@@ -192,29 +149,22 @@ class SendmailTransport {
                 stream = sourceStream.pipe(this.winbreak ? new LeWindows() : new LeUnix());
                 sourceStream.once('error', err => stream.emit('error', err));
             }
-
             stream.once('error', err => {
-                this.logger.error(
-                    {
-                        err,
-                        tnx: 'stdin',
-                        messageId
-                    },
-                    'Error occurred when generating message %s. %s',
-                    messageId,
-                    err.message
-                );
+                this.logger.error({
+                    err,
+                    tnx: 'stdin',
+                    messageId
+                }, 'Error occurred when generating message %s. %s', messageId, err.message);
                 sendmail.kill('SIGINT'); // do not deliver the message
                 callback(err);
             });
-
             stream.pipe(sendmail.stdin);
-        } else {
+        }
+        else {
             const err = new Error('sendmail was not found');
             err.code = errors.ESENDMAIL;
             return callback(err);
         }
     }
 }
-
-module.exports = SendmailTransport;
+export default SendmailTransport;

package/dist/node_modules/nodemailer/dist/esm/ses-transport/index.d.ts

@@ -0,0 +1,112 @@
+import EventEmitter from 'node:events';
+import type { Logger } from '../shared/index.js';
+import { type MimeNodeEnvelope } from '../mime-node/index.js';
+import type MailMessage from '../mailer/mail-message.js';
+import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOptions, VerifyCallback } from '../mailer/index.js';
+/**
+ * Options for the SES transport
+ */
+export interface SESTransportOptions extends TransportOptions {
+    /** The AWS SDK v3 objects to send with, `{ sesClient, SendEmailCommand }` from @aws-sdk/client-sesv2 */
+    SES: {
+        /** SESv2Client instance. Its config.region provider is resolved for the domain of the returned Message-ID */
+        sesClient: {
+            config?: {
+                region?: (() => Promise<string>) | undefined;
+                [key: string]: any;
+            } | undefined;
+            send(command: unknown): Promise<any>;
+        };
+        /** SendEmailCommand class, constructed with the SendEmailCommandInput of every message */
+        SendEmailCommand: new (input: any) => unknown;
+    };
+}
+/** The SESv2Client shape the transport needs */
+export type SESTransportClient = SESTransportOptions['SES']['sesClient'];
+/** The SendEmailCommand constructor shape the transport needs */
+export type SESTransportSendEmailCommand = SESTransportOptions['SES']['SendEmailCommand'];
+/**
+ * SendEmailCommand parameters, the shape of the `ses` message option that is merged into
+ * the API call. Any further SendEmailCommandInput field is accepted as well
+ */
+export interface SESSendEmailRequest {
+    FromEmailAddress?: string | undefined;
+    Destination?: {
+        ToAddresses?: string[] | undefined;
+        CcAddresses?: string[] | undefined;
+        BccAddresses?: string[] | undefined;
+    } | undefined;
+    ReplyToAddresses?: string[] | undefined;
+    Content?: unknown;
+    EmailTags?: Array<{
+        Name?: string | undefined;
+        Value?: string | undefined;
+    }> | undefined;
+    ConfigurationSetName?: string | undefined;
+    ListManagementOptions?: unknown;
+    FeedbackForwardingEmailAddress?: string | undefined;
+    [key: string]: unknown;
+}
+/**
+ * The value the SES transport hands to the send callback
+ */
+export interface SESSentMessageInfo extends SentMessageInfo {
+    /** The envelope the message was sent with */
+    envelope: MimeNodeEnvelope;
+    /** Message-ID built from the MessageId SES returned */
+    messageId: string;
+    /** The MessageId SES returned */
+    response: string;
+    /** The raw RFC822 message that was sent */
+    raw: Buffer;
+}
+/**
+ * Generates a Transport object for AWS SES
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+declare class SESTransport extends EventEmitter {
+    mailer: Mail<SESSentMessageInfo>;
+    options: SESTransportOptions;
+    ses: SESTransportOptions['SES'];
+    name: string;
+    version: string;
+    logger: Logger;
+    constructor(options: SESTransportOptions);
+    getRegion(cb: (err: Error | null, region?: string | false) => void): void;
+    /**
+     * Compiles a mailcomposer message and forwards it to SES
+     *
+     * @param mail MailComposer object
+     * @param callback Callback function to run when the sending is completed
+     */
+    send(mail: MailMessage<SESSentMessageInfo>, callback: (err: Error | null, info?: SESSentMessageInfo) => void): void;
+    /**
+     * Verifies SES configuration
+     *
+     * @returns Promise that resolves to true if the configuration is usable
+     */
+    verify(): Promise<true>;
+    /**
+     * Verifies SES configuration
+     *
+     * @param callback Callback function
+     */
+    verify(callback: VerifyCallback): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `SESTransport.Options` style references keep working
+ */
+declare namespace SESTransport {
+    type Options = SESTransportOptions;
+    type MailOptions = SendMailOptions;
+    type SentMessageInfo = SESSentMessageInfo;
+    type SESv2ClientLike = SESTransportClient;
+    type SendEmailCommandConstructorLike = SESTransportSendEmailCommand;
+    type SendEmailRequestLike = SESSendEmailRequest;
+    type MailSesOptions = SESSendEmailRequest;
+}
+/** The same aliases as module level exports, for `import * as SESTransport` and `import SESTransport = require()` */
+export type { SESTransportOptions as Options, SendMailOptions as MailOptions, SESSentMessageInfo as SentMessageInfo, SESTransportClient as SESv2ClientLike, SESTransportSendEmailCommand as SendEmailCommandConstructorLike, SESSendEmailRequest as SendEmailRequestLike, SESSendEmailRequest as MailSesOptions };
+export default SESTransport;

package/dist/node_modules/nodemailer/dist/esm/ses-transport/index.js

@@ -0,0 +1,212 @@
+import EventEmitter from 'node:events';
+import * as packageData from '../package-info.js';
+import * as shared from '../shared/index.js';
+import * as errors from '../errors.js';
+import LeWindows from '../mime-node/le-windows.js';
+import MimeNode from '../mime-node/index.js';
+/**
+ * Tags AWS SDK rejections that carry no `code` property (SDK v3 errors only
+ * have a `name`) with the generic SES transport error code, keeping the
+ * original error object intact
+ */
+function tagSesError(err) {
+    if (err && typeof err === 'object' && !err.code) {
+        err.code = errors.ESES;
+    }
+    return err;
+}
+/**
+ * Generates a Transport object for AWS SES
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+class SESTransport extends EventEmitter {
+    constructor(options) {
+        super();
+        if (!options || !options.SES || !options.SES.sesClient) {
+            const error = new Error('Missing SES configuration, expecting { sesClient, SendEmailCommand } from @aws-sdk/client-sesv2, see https://nodemailer.com/transports/ses/');
+            error.code = errors.ECONFIG;
+            throw error;
+        }
+        this.options = options;
+        this.ses = this.options.SES;
+        this.name = 'SESTransport';
+        this.version = packageData.version;
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'ses-transport'
+        });
+    }
+    getRegion(cb) {
+        if (this.ses.sesClient.config && typeof this.ses.sesClient.config.region === 'function') {
+            // Resolve the region provider. Use the two-argument form of then() so that a
+            // synchronous throw from cb is not recaught here and used to invoke cb a second time.
+            this.ses.sesClient.config.region().then(region => cb(null, region), err => cb(err));
+            return;
+        }
+        return cb(null, false);
+    }
+    /**
+     * Compiles a mailcomposer message and forwards it to SES
+     *
+     * @param mail MailComposer object
+     * @param callback Callback function to run when the sending is completed
+     */
+    send(mail, callback) {
+        // send() runs after the message was compiled, so mail.message is set
+        let fromHeader = mail.message._headers.find(header => /^from$/i.test(header.key));
+        if (fromHeader) {
+            const mimeNode = new MimeNode('text/plain');
+            fromHeader = mimeNode._convertAddresses(mimeNode._parseAddresses(fromHeader.value));
+        }
+        const envelope = mail.message.getEnvelope();
+        const messageId = mail.message.messageId();
+        const recipients = [].concat(envelope.to || []);
+        if (recipients.length > 3) {
+            recipients.push('...and ' + recipients.splice(2).length + ' more');
+        }
+        this.logger.info({
+            tnx: 'send',
+            messageId
+        }, 'Sending message %s to <%s>', messageId, recipients.join(', '));
+        const getRawMessage = (next) => {
+            // do not use Message-ID and Date in DKIM signature
+            if (!mail.data._dkim) {
+                mail.data._dkim = {};
+            }
+            if (mail.data._dkim.skipFields && typeof mail.data._dkim.skipFields === 'string') {
+                mail.data._dkim.skipFields += ':date:message-id';
+            }
+            else {
+                mail.data._dkim.skipFields = 'date:message-id';
+            }
+            const sourceStream = mail.message.createReadStream();
+            const stream = sourceStream.pipe(new LeWindows());
+            const chunks = [];
+            let chunklen = 0;
+            stream.on('readable', () => {
+                let chunk;
+                while ((chunk = stream.read()) !== null) {
+                    chunks.push(chunk);
+                    chunklen += chunk.length;
+                }
+            });
+            sourceStream.once('error', err => stream.emit('error', err));
+            stream.once('error', err => next(err));
+            stream.once('end', () => next(null, Buffer.concat(chunks, chunklen)));
+        };
+        setImmediate(() => getRawMessage((err, raw) => {
+            if (err) {
+                this.logger.error({
+                    err,
+                    tnx: 'send',
+                    messageId
+                }, 'Failed creating message for %s. %s', messageId, err.message);
+                return callback(err);
+            }
+            // mail.data.ses is caller supplied message data, so copy its own keys only
+            const sesMessage = shared.copyOwnKeys({
+                Content: {
+                    Raw: {
+                        // required
+                        Data: raw // required
+                    }
+                },
+                FromEmailAddress: fromHeader || envelope.from,
+                Destination: {
+                    ToAddresses: envelope.to
+                }
+            }, mail.data.ses);
+            this.getRegion((err, region) => {
+                if (err || !region) {
+                    region = 'us-east-1';
+                }
+                let sendPromise;
+                try {
+                    // command construction or dispatch can throw synchronously on a
+                    // misconfigured SDK; surface it as a single error callback instead
+                    // of letting it escape into getRegion's promise chain
+                    const command = new this.ses.SendEmailCommand(sesMessage);
+                    sendPromise = this.ses.sesClient.send(command);
+                }
+                catch (err) {
+                    tagSesError(err);
+                    this.logger.error({
+                        err,
+                        tnx: 'send'
+                    }, 'Send error for %s: %s', messageId, err.message);
+                    setImmediate(() => callback(err));
+                    return;
+                }
+                sendPromise
+                    .then(data => {
+                    if (region === 'us-east-1') {
+                        region = 'email';
+                    }
+                    const info = {
+                        envelope: {
+                            from: envelope.from,
+                            to: envelope.to
+                        },
+                        messageId: '<' + data.MessageId + (!/@/.test(data.MessageId) ? '@' + region + '.amazonses.com' : '') + '>',
+                        response: data.MessageId,
+                        raw: raw
+                    };
+                    // invoke the callback outside the promise chain so a throw from it
+                    // is not recaught by .catch() and used to call it a second time
+                    setImmediate(() => callback(null, info));
+                })
+                    .catch(err => {
+                    tagSesError(err);
+                    this.logger.error({
+                        err,
+                        tnx: 'send'
+                    }, 'Send error for %s: %s', messageId, err.message);
+                    setImmediate(() => callback(err));
+                });
+            });
+        }));
+    }
+    verify(callback) {
+        let promise;
+        if (!callback) {
+            promise = new Promise((resolve, reject) => {
+                callback = shared.callbackPromise(resolve, reject);
+            });
+        }
+        const done = callback;
+        const cb = (err) => {
+            if (err && !['InvalidParameterValue', 'MessageRejected'].includes(err.code || err.Code || err.name)) {
+                return done(tagSesError(err));
+            }
+            return done(null, true);
+        };
+        const sesMessage = {
+            Content: {
+                Raw: {
+                    Data: Buffer.from('From: <invalid@invalid>\r\nTo: <invalid@invalid>\r\n Subject: Invalid\r\n\r\nInvalid')
+                }
+            },
+            FromEmailAddress: 'invalid@invalid',
+            Destination: {
+                ToAddresses: ['invalid@invalid']
+            }
+        };
+        // the region value is not used for anything when verifying, but the lookup
+        // exercises the client configuration the same way as send() does
+        this.getRegion(() => {
+            let sendPromise;
+            try {
+                const command = new this.ses.SendEmailCommand(sesMessage);
+                sendPromise = this.ses.sesClient.send(command);
+            }
+            catch (err) {
+                setImmediate(() => cb(err));
+                return;
+            }
+            sendPromise.then(() => setImmediate(() => cb(null))).catch(err => setImmediate(() => cb(err)));
+        });
+        return promise;
+    }
+}
+export default SESTransport;