@nocobase/plugin-workflow-mailer 2.3.0-beta.9 → 2.4.0-alpha.10

package/dist/node_modules/nodemailer/{lib → dist/esm}/qp/index.js

@@ -1,64 +1,59 @@
-'use strict';
-
-const Transform = require('stream').Transform;
-
+import { Transform } from 'node:stream';
 /**
  * Encodes a Buffer into a Quoted-Printable encoded string
  *
- * @param {Buffer} buffer Buffer to convert
- * @returns {String} Quoted-Printable encoded string
+ * @param buffer Buffer to convert
+ * @returns Quoted-Printable encoded string
  */
-function encode(buffer) {
+// 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{|}
+];
+export function encode(buffer) {
     if (typeof buffer === 'string') {
         buffer = Buffer.from(buffer, 'utf-8');
     }
-
-    // usable characters that do not need encoding
-    let ranges = [
-        // https://tools.ietf.org/html/rfc2045#section-6.7
-        [0x09], // <TAB>
-        [0x0a], // <LF>
-        [0x0d], // <CR>
-        [0x20, 0x3c], // <SP>!"#$%&'()*+,-./0123456789:;
-        [0x3e, 0x7e] // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
-    ];
     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, ranges) && !((ord === 0x20 || ord === 0x09) && (i === len - 1 || buffer[i + 1] === 0x0a || buffer[i + 1] === 0x0d))) {
+        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 {String} str Quoted-Printable encoded string that might need line wrapping
- * @param {Number} [lineLength=76] Maximum allowed length for a line
- * @returns {String} Soft-wrapped Quoted-Printable encoded 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) {
+export function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = lineLength || 76;
-
+    // 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;
-    let len = str.length;
+    const len = str.length;
     let match, code, line;
-    let lineMargin = Math.floor(lineLength / 3);
+    const lineMargin = Math.floor(lineLength / 3);
     let result = '';
-
     // insert soft linebreaks where needed
     while (pos < len) {
         line = str.substr(pos, lineLength);
@@ -68,119 +63,114 @@ function wrap(str, lineLength) {
             pos += line.length;
             continue;
         }
-
         if (line.substr(-1) === '\n') {
-            // nothing to change here
             result += line;
             pos += line.length;
             continue;
-        } else if ((match = line.substr(-lineMargin).match(/\n.*?$/))) {
+        }
+        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;
-        } else if (line.length > lineLength - lineMargin && (match = line.substr(-lineMargin).match(/[ \t.,!?][^ \t.,!?]*$/))) {
+        }
+        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)) {
+        }
+        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))) {
+            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) {
+            }
+            else if (line.length === lineLength) {
                 line = line.substr(0, line.length - 1);
             }
             pos += line.length;
             line += '=\r\n';
-        } else {
+        }
+        else {
             pos += line.length;
         }
-
         result += line;
     }
-
     return result;
 }
-
 /**
  * Helper function to check if a number is inside provided ranges
  *
- * @param {Number} nr Number to check for
- * @param {Array} ranges An Array of allowed values
- * @returns {Boolean} True if the value was found inside allowed ranges, false otherwise
+ * @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--) {
-        if (!ranges[i].length) {
+        const range = ranges[i];
+        if (!range.length) {
             continue;
         }
-        if (ranges[i].length === 1 && nr === ranges[i][0]) {
+        if (range.length === 1 && nr === range[0]) {
             return true;
         }
-        if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) {
+        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 {Object} options Stream options
- * @param {Number} [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
  */
-class Encoder extends Transform {
+export class Encoder extends Transform {
     constructor(options) {
         super();
-
-        // init Transform
         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);
@@ -188,20 +178,19 @@ class Encoder extends Transform {
                 this._curLine = lastLine;
                 return lineBreak;
             });
-
             if (qp) {
                 this.outputBytes += qp.length;
                 this.push(qp);
             }
-        } else {
+        }
+        else {
             qp = encode(chunk);
             this.outputBytes += qp.length;
             this.push(qp, 'ascii');
         }
-
         done();
     }
-
+    /** @internal */
     _flush(done) {
         if (this._curLine) {
             this.outputBytes += this._curLine.length;
@@ -210,10 +199,3 @@ class Encoder extends Transform {
         done();
     }
 }
-
-// expose to the world
-module.exports = {
-    encode,
-    wrap,
-    Encoder
-};

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/dist/esm/sendmail-transport/index.js

@@ -0,0 +1,170 @@
+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
+ *
+ * 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 = 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 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);
+                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);
+        }
+    }
+}
+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;