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

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

@@ -1,416 +0,0 @@
-'use strict';
-
-const EventEmitter = require('events');
-const SMTPConnection = require('../smtp-connection');
-const wellKnown = require('../well-known');
-const shared = require('../shared');
-const XOAuth2 = require('../xoauth2');
-const packageData = require('../../package.json');
-
-/**
- * Creates a SMTP transport object for Nodemailer
- *
- * @constructor
- * @param {Object} 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'
-        });
-
-        // temporary object
-        let connection = new SMTPConnection(this.options);
-
-        this.name = 'SMTP';
-        this.version = packageData.version + '[client:' + connection.version + ']';
-
-        if (this.options.auth) {
-            this.auth = this.getAuth({});
-        }
-    }
-
-    /**
-     * Placeholder function for creating proxy sockets. This method immediatelly returns
-     * without a socket
-     *
-     * @param {Object} options Connection options
-     * @param {Function} callback Callback function to run with the socket keys
-     */
-    getSocket(options, callback) {
-        // return immediatelly
-        return setImmediate(() => callback(null, false));
-    }
-
-    getAuth(authOpts) {
-        if (!authOpts) {
-            return this.auth;
-        }
-
-        let hasAuth = false;
-        let authData = {};
-
-        if (this.options.auth && typeof this.options.auth === 'object') {
-            Object.keys(this.options.auth).forEach(key => {
-                hasAuth = true;
-                authData[key] = this.options.auth[key];
-            });
-        }
-
-        if (authOpts && typeof authOpts === 'object') {
-            Object.keys(authOpts).forEach(key => {
-                hasAuth = true;
-                authData[key] = authOpts[key];
-            });
-        }
-
-        if (!hasAuth) {
-            return false;
-        }
-
-        switch ((authData.type || '').toString().toUpperCase()) {
-            case 'OAUTH2': {
-                if (!authData.service && !authData.user) {
-                    return false;
-                }
-                let 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 {Object} mail Mail object
-     * @param {Function} 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 = shared.assign(false, options);
-                Object.keys(socketOptions).forEach(key => {
-                    options[key] = socketOptions[key];
-                });
-            }
-
-            let connection = new SMTPConnection(options);
-
-            connection.once('error', err => {
-                if (returned) {
-                    return;
-                }
-                returned = true;
-                connection.close();
-                return callback(err);
-            });
-
-            connection.once('end', () => {
-                if (returned) {
-                    return;
-                }
-
-                let timer = setTimeout(() => {
-                    if (returned) {
-                        return;
-                    }
-                    returned = true;
-                    // still have not returned, this means we have an unexpected connection close
-                    let err = new Error('Unexpected socket close');
-                    if (connection && connection._socket && connection._socket.upgrading) {
-                        // starttls connection errors
-                        err.code = 'ETLS';
-                    }
-                    callback(err);
-                }, 1000);
-
-                try {
-                    timer.unref();
-                } catch (E) {
-                    // Ignore. Happens on envs with non-node timer implementation
-                }
-            });
-
-            let sendMessage = () => {
-                let envelope = mail.message.getEnvelope();
-                let messageId = mail.message.messageId();
-
-                let 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;
-                }
-
-                this.logger.info(
-                    {
-                        tnx: 'send',
-                        messageId
-                    },
-                    'Sending message %s to <%s>',
-                    messageId,
-                    recipients.join(', ')
-                );
-
-                connection.send(envelope, mail.message.createReadStream(), (err, info) => {
-                    returned = true;
-                    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(() => {
-                if (returned) {
-                    return;
-                }
-
-                let auth = this.getAuth(mail.data.auth);
-
-                if (auth && (connection.allowsAuth || options.forceAuth)) {
-                    connection.login(auth, err => {
-                        if (auth && auth !== this.auth && auth.oauth2) {
-                            auth.oauth2.removeAllListeners();
-                        }
-                        if (returned) {
-                            return;
-                        }
-
-                        if (err) {
-                            returned = true;
-                            connection.close();
-                            return callback(err);
-                        }
-
-                        sendMessage();
-                    });
-                } else {
-                    sendMessage();
-                }
-            });
-        });
-    }
-
-    /**
-     * Verifies SMTP configuration
-     *
-     * @param {Function} callback Callback function
-     */
-    verify(callback) {
-        let promise;
-
-        if (!callback) {
-            promise = new Promise((resolve, reject) => {
-                callback = shared.callbackPromise(resolve, reject);
-            });
-        }
-
-        this.getSocket(this.options, (err, socketOptions) => {
-            if (err) {
-                return callback(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 = shared.assign(false, options);
-                Object.keys(socketOptions).forEach(key => {
-                    options[key] = socketOptions[key];
-                });
-            }
-
-            let connection = new SMTPConnection(options);
-            let returned = false;
-
-            connection.once('error', err => {
-                if (returned) {
-                    return;
-                }
-                returned = true;
-                connection.close();
-                return callback(err);
-            });
-
-            connection.once('end', () => {
-                if (returned) {
-                    return;
-                }
-                returned = true;
-                return callback(new Error('Connection closed'));
-            });
-
-            let finalize = () => {
-                if (returned) {
-                    return;
-                }
-                returned = true;
-                connection.quit();
-                return callback(null, true);
-            };
-
-            connection.connect(() => {
-                if (returned) {
-                    return;
-                }
-
-                let authData = this.getAuth({});
-
-                if (authData && (connection.allowsAuth || options.forceAuth)) {
-                    connection.login(authData, err => {
-                        if (returned) {
-                            return;
-                        }
-
-                        if (err) {
-                            returned = true;
-                            connection.close();
-                            return callback(err);
-                        }
-
-                        finalize();
-                    });
-                } else if (!authData && connection.allowsAuth && options.forceAuth) {
-                    let err = new Error('Authentication info was not provided');
-                    err.code = 'NoAuth';
-
-                    returned = true;
-                    connection.close();
-                    return callback(err);
-                } else {
-                    finalize();
-                }
-            });
-        });
-
-        return promise;
-    }
-
-    /**
-     * Releases resources
-     */
-    close() {
-        if (this.auth && this.auth.oauth2) {
-            this.auth.oauth2.removeAllListeners();
-        }
-        this.emit('close');
-    }
-}
-
-// expose to the world
-module.exports = SMTPTransport;

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

@@ -1,135 +0,0 @@
-'use strict';
-
-const packageData = require('../../package.json');
-const shared = require('../shared');
-
-/**
- * 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 {Object} 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 {Object} emailMessage MailComposer object
-     * @param {Function} callback Callback function to run when the sending is completed
-     */
-    send(mail, done) {
-        // We probably need this in the output
-        mail.message.keepBcc = true;
-
-        let envelope = mail.data.envelope || mail.message.getEnvelope();
-        let messageId = mail.message.messageId();
-
-        let 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();
-            } 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: mail.data.envelope || mail.message.getEnvelope(),
-                    messageId,
-                    message: stream
-                });
-            }
-
-            let 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: mail.data.envelope || mail.message.getEnvelope(),
-                    messageId,
-                    message: Buffer.concat(chunks, chunklen)
-                })
-            );
-        });
-    }
-}
-
-module.exports = StreamTransport;