@nocobase/plugin-workflow-mailer 2.4.0-alpha.1 → 2.4.0-alpha.11

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

@@ -0,0 +1,331 @@
+import { EventEmitter } from 'node:events';
+import SMTPConnection from '../smtp-connection/index.js';
+import wellKnown from '../well-known/index.js';
+import * as shared from '../shared/index.js';
+import XOAuth2 from '../xoauth2/index.js';
+import * as errors from '../errors.js';
+import * as packageData from '../package-info.js';
+/**
+ * Creates a SMTP transport object for Nodemailer
+ *
+ * @constructor
+ * @param options Connection options
+ */
+class SMTPTransport extends 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 && wellKnown(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 XOAuth2(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 SMTPConnection(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 SMTPConnection(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');
+    }
+}
+export default SMTPTransport;

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

@@ -0,0 +1,106 @@
+import * as packageData from '../package-info.js';
+import * as shared from '../shared/index.js';
+import LeWindows from '../mime-node/le-windows.js';
+import LeUnix from '../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 LeWindows() : new LeUnix());
+                    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)
+            }));
+        });
+    }
+}
+export default StreamTransport;

package/dist/node_modules/nodemailer/dist/esm/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/{lib → dist/esm}/well-known/index.js

@@ -1,47 +1,36 @@
-'use strict';
-
-const services = require('./services.json');
+import { services } from './services.js';
 const normalized = {};
-
 Object.keys(services).forEach(key => {
-    let service = services[key];
-
-    normalized[normalizeKey(key)] = normalizeService(service);
-
+    const service = services[key];
+    const normalizedService = normalizeService(service);
+    normalized[normalizeKey(key)] = normalizedService;
     [].concat(service.aliases || []).forEach(alias => {
-        normalized[normalizeKey(alias)] = normalizeService(service);
+        normalized[normalizeKey(alias)] = normalizedService;
     });
-
     [].concat(service.domains || []).forEach(domain => {
-        normalized[normalizeKey(domain)] = normalizeService(service);
+        normalized[normalizeKey(domain)] = normalizedService;
     });
 });
-
 function normalizeKey(key) {
     return key.replace(/[^a-zA-Z0-9.-]/g, '').toLowerCase();
 }
-
 function normalizeService(service) {
-    let filter = ['domains', 'aliases'];
-    let response = {};
-
+    const response = {};
     Object.keys(service).forEach(key => {
-        if (filter.indexOf(key) < 0) {
+        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 {String} key [description]
- * @returns {Object} SMTP config or false if not found
+ * @param key Service name, alias or an email address
+ * @returns SMTP config or false if not found
  */
-module.exports = function (key) {
+export default function wellKnown(key) {
     key = normalizeKey(key.split('@').pop());
     return normalized[key] || false;
-};
+}

package/dist/node_modules/nodemailer/dist/esm/well-known/services.d.ts

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