@nocobase/plugin-workflow-mailer 2.3.0-beta.12 → 2.3.0-beta.14

package/dist/node_modules/nodemailer/dist/cjs/qp/index.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encoder = void 0;
+exports.encode = encode;
+exports.wrap = wrap;
+const node_stream_1 = require("node:stream");
+/**
+ * Encodes a Buffer into a Quoted-Printable encoded string
+ *
+ * @param buffer Buffer to convert
+ * @returns Quoted-Printable encoded string
+ */
+// the shortest line wrap() can make progress with: a complete =XX sequence and the soft break
+const MIN_LINE_LENGTH = 4;
+// usable characters that do not need encoding
+// https://tools.ietf.org/html/rfc2045#section-6.7
+const QP_RANGES = [
+    [0x09], // <TAB>
+    [0x0a], // <LF>
+    [0x0d], // <CR>
+    [0x20, 0x3c], // <SP>!"#$%&'()*+,-./0123456789:;
+    [0x3e, 0x7e] // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
+];
+function encode(buffer) {
+    if (typeof buffer === 'string') {
+        buffer = Buffer.from(buffer, 'utf-8');
+    }
+    let result = '';
+    let ord;
+    for (let i = 0, len = buffer.length; i < len; i++) {
+        ord = buffer[i];
+        // if the char is in allowed range, then keep as is, unless it is a WS in the end of a line
+        if (checkRanges(ord, QP_RANGES) &&
+            !((ord === 0x20 || ord === 0x09) && (i === len - 1 || buffer[i + 1] === 0x0a || buffer[i + 1] === 0x0d))) {
+            result += String.fromCharCode(ord);
+            continue;
+        }
+        result += '=' + (ord < 0x10 ? '0' : '') + ord.toString(16).toUpperCase();
+    }
+    return result;
+}
+/**
+ * Adds soft line breaks to a Quoted-Printable string
+ *
+ * @param str Quoted-Printable encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped Quoted-Printable encoded string
+ */
+function wrap(str, lineLength) {
+    str = (str || '').toString();
+    // a line has to hold a complete =XX sequence plus the soft break, shorter lengths
+    // (or a negative one) would loop without consuming input
+    lineLength = Math.max(Number(lineLength) || 76, MIN_LINE_LENGTH);
+    if (str.length <= lineLength) {
+        return str;
+    }
+    let pos = 0;
+    const len = str.length;
+    let match, code, line;
+    const lineMargin = Math.floor(lineLength / 3);
+    let result = '';
+    // insert soft linebreaks where needed
+    while (pos < len) {
+        line = str.substr(pos, lineLength);
+        if ((match = line.match(/\r\n/))) {
+            line = line.substr(0, match.index + match[0].length);
+            result += line;
+            pos += line.length;
+            continue;
+        }
+        if (line.substr(-1) === '\n') {
+            result += line;
+            pos += line.length;
+            continue;
+        }
+        if ((match = line.substr(-lineMargin).match(/\n.*?$/))) {
+            // truncate to nearest line break
+            line = line.substr(0, line.length - (match[0].length - 1));
+            result += line;
+            pos += line.length;
+            continue;
+        }
+        if (line.length > lineLength - lineMargin && (match = line.substr(-lineMargin).match(/[ \t.,!?][^ \t.,!?]*$/))) {
+            // truncate to nearest space
+            line = line.substr(0, line.length - (match[0].length - 1));
+        }
+        else if (line.match(/[=][\da-f]{0,2}$/i)) {
+            // push incomplete encoding sequences to the next line
+            if ((match = line.match(/[=][\da-f]{0,1}$/i))) {
+                line = line.substr(0, line.length - match[0].length);
+            }
+            // ensure that utf-8 sequences are not split
+            while (line.length > 3 &&
+                line.length < len - pos &&
+                !line.match(/^(?:=[\da-f]{2}){1,4}$/i) &&
+                (match = line.match(/[=][\da-f]{2}$/gi))) {
+                code = parseInt(match[0].substr(1, 2), 16);
+                if (code < 128) {
+                    break;
+                }
+                line = line.substr(0, line.length - 3);
+                if (code >= 0xc0) {
+                    break;
+                }
+            }
+        }
+        if (!line.length) {
+            // the trimming above emptied the line, which only happens for an incomplete
+            // escape at the very end of the input. Take it as is rather than loop on it
+            line = str.substr(pos, lineLength);
+        }
+        if (pos + line.length < len && line.substr(-1) !== '\n') {
+            if (line.length === lineLength && line.match(/[=][\da-f]{2}$/i)) {
+                line = line.substr(0, line.length - 3);
+            }
+            else if (line.length === lineLength) {
+                line = line.substr(0, line.length - 1);
+            }
+            pos += line.length;
+            line += '=\r\n';
+        }
+        else {
+            pos += line.length;
+        }
+        result += line;
+    }
+    return result;
+}
+/**
+ * Helper function to check if a number is inside provided ranges
+ *
+ * @param nr Number to check for
+ * @param ranges An Array of allowed values
+ * @returns True if the value was found inside allowed ranges, false otherwise
+ */
+function checkRanges(nr, ranges) {
+    for (let i = ranges.length - 1; i >= 0; i--) {
+        const range = ranges[i];
+        if (!range.length) {
+            continue;
+        }
+        if (range.length === 1 && nr === range[0]) {
+            return true;
+        }
+        if (range.length === 2 && nr >= range[0] && nr <= range[1]) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Creates a transform stream for encoding data to Quoted-Printable encoding
+ *
+ * @constructor
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ */
+class Encoder extends node_stream_1.Transform {
+    constructor(options) {
+        super();
+        this.options = options || {};
+        if (this.options.lineLength !== false) {
+            this.options.lineLength = this.options.lineLength || 76;
+        }
+        this._curLine = '';
+        this.inputBytes = 0;
+        this.outputBytes = 0;
+    }
+    /** @internal */
+    _transform(chunk, encoding, done) {
+        let qp;
+        if (encoding !== 'buffer') {
+            chunk = Buffer.from(chunk, encoding);
+        }
+        if (!chunk || !chunk.length) {
+            return done();
+        }
+        this.inputBytes += chunk.length;
+        if (this.options.lineLength) {
+            qp = this._curLine + encode(chunk);
+            qp = wrap(qp, this.options.lineLength);
+            qp = qp.replace(/(^|\n)([^\n]*)$/, (match, lineBreak, lastLine) => {
+                this._curLine = lastLine;
+                return lineBreak;
+            });
+            if (qp) {
+                this.outputBytes += qp.length;
+                this.push(qp);
+            }
+        }
+        else {
+            qp = encode(chunk);
+            this.outputBytes += qp.length;
+            this.push(qp, 'ascii');
+        }
+        done();
+    }
+    /** @internal */
+    _flush(done) {
+        if (this._curLine) {
+            this.outputBytes += this._curLine.length;
+            this.push(this._curLine, 'ascii');
+        }
+        done();
+    }
+}
+exports.Encoder = Encoder;

package/dist/node_modules/nodemailer/dist/cjs/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/dist/cjs/sendmail-transport/index.js

@@ -0,0 +1,210 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const packageData = __importStar(require("../package-info.js"));
+const shared = __importStar(require("../shared/index.js"));
+const errors = __importStar(require("../errors.js"));
+const le_windows_js_1 = __importDefault(require("../mime-node/le-windows.js"));
+const le_unix_js_1 = __importDefault(require("../mime-node/le-unix.js"));
+/**
+ * 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
+ */
+class SendmailTransport {
+    constructor(options) {
+        options = options || {};
+        // use a reference to spawn for mocking purposes
+        this._spawn = node_child_process_1.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') {
+            if (options.path) {
+                this.path = options.path;
+            }
+            if (Array.isArray(options.args)) {
+                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 mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail, done) {
+        // 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 || [])
+            // a local part is either a dot-atom or a quoted-string, so a leading dash sits at
+            // offset 0 or, behind the opening quote, at offset 1. Only the first shape is read
+            // as an option by sendmail, but both are the address this guard keeps out of argv
+            .some(addr => /^"?-/.test(addr));
+        if (hasInvalidAddresses) {
+            const err = new Error('Can not send mail. Invalid envelope addresses.');
+            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) => {
+            if (returned) {
+                // ignore any additional responses, already done
+                return;
+            }
+            returned = true;
+            if (typeof done === 'function') {
+                if (err) {
+                    return done(err);
+                }
+                return done(null, {
+                    envelope,
+                    messageId,
+                    response: 'Messages queued for delivery'
+                });
+            }
+        };
+        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);
+            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);
+                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);
+                err.code = errors.ESENDMAIL;
+                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);
+                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(', '));
+            const sourceStream = mail.message.createReadStream();
+            let stream = sourceStream;
+            if (this.options.newline) {
+                // apply the transport-level line ending transform; the message-level
+                // `newline` option is handled by MimeNode in createReadStream()
+                stream = sourceStream.pipe(this.winbreak ? new le_windows_js_1.default() : new le_unix_js_1.default());
+                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);
+                sendmail.kill('SIGINT'); // do not deliver the message
+                callback(err);
+            });
+            stream.pipe(sendmail.stdin);
+        }
+        else {
+            const err = new Error('sendmail was not found');
+            err.code = errors.ESENDMAIL;
+            return callback(err);
+        }
+    }
+}
+exports.default = SendmailTransport;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/node_modules/nodemailer/dist/cjs/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;