@nocobase/plugin-workflow-mailer 2.3.0-beta.13 → 2.3.0-beta.15

package/dist/node_modules/nodemailer/dist/cjs/smtp-transport/index.js

@@ -0,0 +1,371 @@
+"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_events_1 = require("node:events");
+const index_js_1 = __importDefault(require("../smtp-connection/index.js"));
+const index_js_2 = __importDefault(require("../well-known/index.js"));
+const shared = __importStar(require("../shared/index.js"));
+const index_js_3 = __importDefault(require("../xoauth2/index.js"));
+const errors = __importStar(require("../errors.js"));
+const packageData = __importStar(require("../package-info.js"));
+/**
+ * Creates a SMTP transport object for Nodemailer
+ *
+ * @constructor
+ * @param options Connection options
+ */
+class SMTPTransport extends node_events_1.EventEmitter {
+    constructor(options) {
+        super();
+        options = options || {};
+        if (typeof options === 'string') {
+            options = {
+                url: options
+            };
+        }
+        let urlData;
+        let service = options.service;
+        if (typeof options.getSocket === 'function') {
+            this.getSocket = options.getSocket;
+        }
+        if (options.url) {
+            urlData = shared.parseConnectionUrl(options.url);
+            service = service || urlData.service;
+        }
+        this.options = shared.assign(false, // create new object
+        options, // regular options
+        urlData, // url options
+        (service && (0, index_js_2.default)(service)) // wellknown options
+        );
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'smtp-transport'
+        });
+        this.name = 'SMTP';
+        this.version = packageData.version + '[client:' + packageData.version + ']';
+        if (this.options.auth) {
+            this.auth = this.getAuth({});
+        }
+    }
+    /**
+     * Placeholder function for creating proxy sockets. This method immediatelly returns
+     * without a socket
+     *
+     * @param options Connection options
+     * @param callback Callback function to run with the socket keys
+     */
+    getSocket(options, callback) {
+        // return immediatelly
+        setImmediate(() => callback(null, false));
+    }
+    getAuth(authOpts) {
+        if (!authOpts) {
+            if (this.auth && this.auth.oauth2 && this.mailer) {
+                // Transport-level auth is resolved in the constructor, before the Mail wrapper
+                // assigns `this.mailer`, so a provision callback registered with
+                // `transporter.set('oauth2_provision_cb', ...)` has to be re-checked here
+                this.auth.oauth2.provisionCallback = this.mailer.get('oauth2_provision_cb') || this.auth.oauth2.provisionCallback;
+            }
+            return this.auth;
+        }
+        const authData = Object.assign({}, this.options.auth && typeof this.options.auth === 'object' ? this.options.auth : {}, typeof authOpts === 'object' ? authOpts : {});
+        if (Object.keys(authData).length === 0) {
+            return false;
+        }
+        switch ((authData.type || '').toString().toUpperCase()) {
+            case 'OAUTH2': {
+                if (!authData.service && !authData.user) {
+                    return false;
+                }
+                const oauth2 = new index_js_3.default(authData, this.logger);
+                oauth2.provisionCallback = (this.mailer && this.mailer.get('oauth2_provision_cb')) || oauth2.provisionCallback;
+                oauth2.on('token', (token) => this.mailer.emit('token', token));
+                oauth2.on('error', err => this.emit('error', err));
+                return {
+                    type: 'OAUTH2',
+                    user: authData.user,
+                    oauth2,
+                    method: 'XOAUTH2'
+                };
+            }
+            default:
+                return {
+                    type: (authData.type || '').toString().toUpperCase() || 'LOGIN',
+                    user: authData.user,
+                    credentials: {
+                        user: authData.user || '',
+                        pass: authData.pass,
+                        options: authData.options
+                    },
+                    method: (authData.method || '').trim().toUpperCase() || this.options.authMethod || false
+                };
+        }
+    }
+    /**
+     * Sends an e-mail using the selected settings
+     *
+     * @param mail Mail object
+     * @param callback Callback function
+     */
+    send(mail, callback) {
+        this.getSocket(this.options, (err, socketOptions) => {
+            if (err) {
+                return callback(err);
+            }
+            let returned = false;
+            let options = this.options;
+            if (socketOptions && socketOptions.connection) {
+                this.logger.info({
+                    tnx: 'proxy',
+                    remoteAddress: socketOptions.connection.remoteAddress,
+                    remotePort: socketOptions.connection.remotePort,
+                    destHost: options.host || '',
+                    destPort: options.port || '',
+                    action: 'connected'
+                }, 'Using proxied socket from %s:%s to %s:%s', socketOptions.connection.remoteAddress, socketOptions.connection.remotePort, options.host || '', options.port || '');
+                // only copy options if we need to modify it
+                options = Object.assign(shared.assign(false, options), socketOptions);
+            }
+            const connection = new index_js_1.default(options);
+            let perCallAuth;
+            const cleanupPerCallAuth = () => {
+                if (perCallAuth && perCallAuth !== this.auth && perCallAuth.oauth2) {
+                    perCallAuth.oauth2.removeAllListeners();
+                }
+                perCallAuth = null;
+            };
+            connection.once('error', err => {
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                cleanupPerCallAuth();
+                connection.close();
+                return callback(err);
+            });
+            const sendMessage = () => {
+                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');
+                }
+                if (mail.data.dsn) {
+                    envelope.dsn = mail.data.dsn;
+                }
+                // RFC 8689: Pass requireTLSExtensionEnabled to envelope for MAIL FROM parameter
+                if (mail.data.requireTLSExtensionEnabled) {
+                    envelope.requireTLSExtensionEnabled = mail.data.requireTLSExtensionEnabled;
+                }
+                this.logger.info({
+                    tnx: 'send',
+                    messageId
+                }, 'Sending message %s to <%s>', messageId, recipients.join(', '));
+                connection.send(envelope, mail.message.createReadStream(), (err, info) => {
+                    if (returned) {
+                        // the connection error handler has already reported this send
+                        return;
+                    }
+                    returned = true;
+                    cleanupPerCallAuth();
+                    connection.close();
+                    if (err) {
+                        this.logger.error({
+                            err,
+                            tnx: 'send'
+                        }, 'Send error for %s: %s', messageId, err.message);
+                        return callback(err);
+                    }
+                    info.envelope = {
+                        from: envelope.from,
+                        to: envelope.to
+                    };
+                    info.messageId = messageId;
+                    try {
+                        return callback(null, info);
+                    }
+                    catch (E) {
+                        this.logger.error({
+                            err: E,
+                            tnx: 'callback'
+                        }, 'Callback error for %s: %s', messageId, E.message);
+                    }
+                });
+            };
+            connection.connect(err => {
+                if (returned) {
+                    return;
+                }
+                if (err) {
+                    // the server closed the connection before the greeting
+                    returned = true;
+                    connection.close();
+                    return callback(err);
+                }
+                perCallAuth = this.getAuth(mail.data.auth);
+                if (perCallAuth && (connection.allowsAuth || options.forceAuth)) {
+                    connection.login(perCallAuth, err => {
+                        cleanupPerCallAuth();
+                        if (returned) {
+                            return;
+                        }
+                        if (err) {
+                            returned = true;
+                            connection.close();
+                            return callback(err);
+                        }
+                        sendMessage();
+                    });
+                }
+                else {
+                    sendMessage();
+                }
+            });
+        });
+    }
+    verify(callback) {
+        let promise;
+        if (!callback) {
+            promise = new Promise((resolve, reject) => {
+                callback = shared.callbackPromise(resolve, reject);
+            });
+        }
+        // the error paths hand over the error alone
+        const done = callback;
+        this.getSocket(this.options, (err, socketOptions) => {
+            if (err) {
+                return done(err);
+            }
+            let options = this.options;
+            if (socketOptions && socketOptions.connection) {
+                this.logger.info({
+                    tnx: 'proxy',
+                    remoteAddress: socketOptions.connection.remoteAddress,
+                    remotePort: socketOptions.connection.remotePort,
+                    destHost: options.host || '',
+                    destPort: options.port || '',
+                    action: 'connected'
+                }, 'Using proxied socket from %s:%s to %s:%s', socketOptions.connection.remoteAddress, socketOptions.connection.remotePort, options.host || '', options.port || '');
+                options = Object.assign(shared.assign(false, options), socketOptions);
+            }
+            const connection = new index_js_1.default(options);
+            let returned = false;
+            let perCallAuth;
+            const cleanupPerCallAuth = () => {
+                if (perCallAuth && perCallAuth !== this.auth && perCallAuth.oauth2) {
+                    perCallAuth.oauth2.removeAllListeners();
+                }
+                perCallAuth = null;
+            };
+            connection.once('error', err => {
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                cleanupPerCallAuth();
+                connection.close();
+                return done(err);
+            });
+            connection.once('end', () => {
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                cleanupPerCallAuth();
+                return done(new Error('Connection closed'));
+            });
+            const finalize = () => {
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                cleanupPerCallAuth();
+                connection.quit();
+                return done(null, true);
+            };
+            connection.connect(err => {
+                if (returned) {
+                    return;
+                }
+                if (err) {
+                    returned = true;
+                    connection.close();
+                    return done(err);
+                }
+                perCallAuth = this.getAuth({});
+                if (perCallAuth && (connection.allowsAuth || options.forceAuth)) {
+                    connection.login(perCallAuth, err => {
+                        cleanupPerCallAuth();
+                        if (returned) {
+                            return;
+                        }
+                        if (err) {
+                            returned = true;
+                            connection.close();
+                            return done(err);
+                        }
+                        finalize();
+                    });
+                }
+                else if (!perCallAuth && connection.allowsAuth && options.forceAuth) {
+                    const err = new Error('Authentication info was not provided');
+                    err.code = errors.ENOAUTH;
+                    returned = true;
+                    cleanupPerCallAuth();
+                    connection.close();
+                    return done(err);
+                }
+                else {
+                    finalize();
+                }
+            });
+        });
+        return promise;
+    }
+    /**
+     * Releases resources
+     */
+    close() {
+        if (this.auth && this.auth.oauth2) {
+            this.auth.oauth2.removeAllListeners();
+        }
+        this.emit('close');
+    }
+}
+exports.default = SMTPTransport;
+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/stream-transport/index.d.ts

@@ -0,0 +1,65 @@
+import type { Readable } from 'node:stream';
+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 Stream transport
+ */
+export interface StreamTransportOptions extends TransportOptions {
+    /** Selects this transport in createTransport */
+    streamTransport?: boolean | undefined;
+    /** If true, the message is returned as a Buffer object instead of a stream */
+    buffer?: boolean | undefined;
+    /** Either 'windows' or 'unix', the line ending of the generated message */
+    newline?: string | undefined;
+}
+/**
+ * The value the Stream transport hands to the send callback
+ */
+export interface StreamSentMessageInfo extends SentMessageInfo {
+    /** The envelope the message was generated with */
+    envelope: MimeNodeEnvelope;
+    /** Message-ID value of the message */
+    messageId: string;
+    /** The generated message, a Buffer when the buffer option is set, a readable stream otherwise */
+    message: Readable | Buffer;
+}
+/**
+ * Generates a Transport object for streaming
+ *
+ * Possible options can be the following:
+ *
+ *  * **buffer** if true, then returns the message as a Buffer object instead of a stream
+ *  * **newline** either 'windows' or 'unix'
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+declare class StreamTransport {
+    mailer: Mail<StreamSentMessageInfo>;
+    options: StreamTransportOptions;
+    name: string;
+    version: string;
+    logger: Logger;
+    winbreak: boolean;
+    constructor(options?: StreamTransportOptions);
+    /**
+     * Compiles a mailcomposer message and forwards it to handler that sends it
+     *
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail: MailMessage<StreamSentMessageInfo>, done: (err: Error | null, info?: StreamSentMessageInfo) => void): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `StreamTransport.Options` style references keep working
+ */
+declare namespace StreamTransport {
+    type Options = StreamTransportOptions;
+    type MailOptions = SendMailOptions;
+    type SentMessageInfo = StreamSentMessageInfo;
+}
+/** The same aliases as module level exports, for `import * as StreamTransport` and `import StreamTransport = require()` */
+export type { StreamTransportOptions as Options, SendMailOptions as MailOptions, StreamSentMessageInfo as SentMessageInfo };
+export default StreamTransport;

package/dist/node_modules/nodemailer/dist/cjs/stream-transport/index.js

@@ -0,0 +1,146 @@
+"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 packageData = __importStar(require("../package-info.js"));
+const shared = __importStar(require("../shared/index.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 streaming
+ *
+ * Possible options can be the following:
+ *
+ *  * **buffer** if true, then returns the message as a Buffer object instead of a stream
+ *  * **newline** either 'windows' or 'unix'
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+class StreamTransport {
+    constructor(options) {
+        options = options || {};
+        this.options = options;
+        this.name = 'StreamTransport';
+        this.version = packageData.version;
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'stream-transport'
+        });
+        this.winbreak = ['win', 'windows', 'dos', '\r\n'].includes((options.newline || '').toString().toLowerCase());
+    }
+    /**
+     * Compiles a mailcomposer message and forwards it to handler that sends it
+     *
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail, done) {
+        // We probably need this in the output. 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();
+        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> using %s line breaks', messageId, recipients.join(', '), this.winbreak ? '<CR><LF>' : '<LF>');
+        setImmediate(() => {
+            let stream;
+            try {
+                stream = mail.message.createReadStream();
+                if (this.options.newline) {
+                    // apply the transport-level line ending transform; the message-level
+                    // `newline` option is handled by MimeNode in createReadStream()
+                    const sourceStream = stream;
+                    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));
+                }
+            }
+            catch (E) {
+                this.logger.error({
+                    err: E,
+                    tnx: 'send',
+                    messageId
+                }, 'Creating send stream failed for %s. %s', messageId, E.message);
+                return done(E);
+            }
+            if (!this.options.buffer) {
+                stream.once('error', err => {
+                    this.logger.error({
+                        err,
+                        tnx: 'send',
+                        messageId
+                    }, 'Failed creating message for %s. %s', messageId, err.message);
+                });
+                return done(null, {
+                    envelope,
+                    messageId,
+                    message: stream
+                });
+            }
+            const chunks = [];
+            let chunklen = 0;
+            stream.on('readable', () => {
+                let chunk;
+                while ((chunk = stream.read()) !== null) {
+                    chunks.push(chunk);
+                    chunklen += chunk.length;
+                }
+            });
+            stream.once('error', err => {
+                this.logger.error({
+                    err,
+                    tnx: 'send',
+                    messageId
+                }, 'Failed creating message for %s. %s', messageId, err.message);
+                return done(err);
+            });
+            stream.on('end', () => done(null, {
+                envelope,
+                messageId,
+                message: Buffer.concat(chunks, chunklen)
+            }));
+        });
+    }
+}
+exports.default = StreamTransport;
+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/well-known/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Connection settings of a well-known e-mail service
+ */
+export interface WellKnownServiceDefinition {
+    /** Human readable description of the service */
+    description?: string | undefined;
+    /** Domains of e-mail addresses hosted by the service */
+    domains?: string[] | undefined;
+    /** Alternative names the service can be looked up by */
+    aliases?: string[] | undefined;
+    /** SMTP hostname */
+    host?: string | undefined;
+    /** SMTP port (a numeric string in a few entries) */
+    port?: number | string | undefined;
+    /** true for implicit TLS (usually port 465) */
+    secure?: boolean | undefined;
+    /** Preferred authentication method */
+    authMethod?: string | undefined;
+    /** Set to true to require STARTTLS on a plaintext connection */
+    requireTLS?: boolean | undefined;
+    /** Set to true to skip STARTTLS */
+    ignoreTLS?: boolean | undefined;
+}
+/**
+ * SMTP settings of a well-known service, without the lookup keys
+ */
+export type WellKnownService = Omit<WellKnownServiceDefinition, 'domains' | 'aliases'>;
+/**
+ * Resolves SMTP config for given key. Key can be a name (like 'Gmail'), alias (like 'Google Mail') or
+ * an email address (like 'test@googlemail.com').
+ *
+ * @param key Service name, alias or an email address
+ * @returns SMTP config or false if not found
+ */
+export default function wellKnown(key: string): WellKnownService | false;

package/dist/node_modules/nodemailer/dist/cjs/well-known/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = wellKnown;
+const services_js_1 = require("./services.js");
+const normalized = {};
+Object.keys(services_js_1.services).forEach(key => {
+    const service = services_js_1.services[key];
+    const normalizedService = normalizeService(service);
+    normalized[normalizeKey(key)] = normalizedService;
+    [].concat(service.aliases || []).forEach(alias => {
+        normalized[normalizeKey(alias)] = normalizedService;
+    });
+    [].concat(service.domains || []).forEach(domain => {
+        normalized[normalizeKey(domain)] = normalizedService;
+    });
+});
+function normalizeKey(key) {
+    return key.replace(/[^a-zA-Z0-9.-]/g, '').toLowerCase();
+}
+function normalizeService(service) {
+    const response = {};
+    Object.keys(service).forEach(key => {
+        if (!['domains', 'aliases'].includes(key)) {
+            response[key] = service[key];
+        }
+    });
+    return response;
+}
+/**
+ * Resolves SMTP config for given key. Key can be a name (like 'Gmail'), alias (like 'Google Mail') or
+ * an email address (like 'test@googlemail.com').
+ *
+ * @param key Service name, alias or an email address
+ * @returns SMTP config or false if not found
+ */
+function wellKnown(key) {
+    key = normalizeKey(key.split('@').pop());
+    return normalized[key] || false;
+}
+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/well-known/services.d.ts

@@ -0,0 +1,2 @@
+import type { WellKnownServiceDefinition } from './index.js';
+export declare const services: Record<string, WellKnownServiceDefinition>;