aiplang 2.0.0 → 2.1.0

package/server/node_modules/nodemailer/lib/smtp-pool/pool-resource.js

@@ -0,0 +1,256 @@
+'use strict';
+
+const SMTPConnection = require('../smtp-connection');
+const assign = require('../shared').assign;
+const XOAuth2 = require('../xoauth2');
+const errors = require('../errors');
+const EventEmitter = require('events');
+
+/**
+ * Creates an element for the pool
+ *
+ * @constructor
+ * @param {Object} options SMTPPool instance
+ */
+class PoolResource extends EventEmitter {
+    constructor(pool) {
+        super();
+
+        this.pool = pool;
+        this.options = pool.options;
+        this.logger = this.pool.logger;
+
+        if (this.options.auth) {
+            switch ((this.options.auth.type || '').toString().toUpperCase()) {
+                case 'OAUTH2': {
+                    const oauth2 = new XOAuth2(this.options.auth, this.logger);
+                    oauth2.provisionCallback =
+                        (this.pool.mailer && this.pool.mailer.get('oauth2_provision_cb')) || oauth2.provisionCallback;
+                    this.auth = {
+                        type: 'OAUTH2',
+                        user: this.options.auth.user,
+                        oauth2,
+                        method: 'XOAUTH2'
+                    };
+                    oauth2.on('token', token => this.pool.mailer.emit('token', token));
+                    oauth2.on('error', err => this.emit('error', err));
+                    break;
+                }
+                default:
+                    if (!this.options.auth.user && !this.options.auth.pass) {
+                        break;
+                    }
+                    this.auth = {
+                        type: (this.options.auth.type || '').toString().toUpperCase() || 'LOGIN',
+                        user: this.options.auth.user,
+                        credentials: {
+                            user: this.options.auth.user || '',
+                            pass: this.options.auth.pass,
+                            options: this.options.auth.options
+                        },
+                        method: (this.options.auth.method || '').trim().toUpperCase() || this.options.authMethod || false
+                    };
+            }
+        }
+
+        this._connection = false;
+        this._connected = false;
+
+        this.messages = 0;
+        this.available = true;
+    }
+
+    /**
+     * Initiates a connection to the SMTP server
+     *
+     * @param {Function} callback Callback function to run once the connection is established or failed
+     */
+    connect(callback) {
+        this.pool.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 || ''
+                );
+
+                options = Object.assign(assign(false, options), socketOptions);
+            }
+
+            this.connection = new SMTPConnection(options);
+
+            this.connection.once('error', err => {
+                this.emit('error', err);
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                return callback(err);
+            });
+
+            this.connection.once('end', () => {
+                this.close();
+                if (returned) {
+                    return;
+                }
+                returned = true;
+
+                const timer = setTimeout(() => {
+                    if (returned) {
+                        return;
+                    }
+                    // still have not returned, this means we have an unexpected connection close
+                    const err = new Error('Unexpected socket close');
+                    if (this.connection && this.connection._socket && this.connection._socket.upgrading) {
+                        // starttls connection errors
+                        err.code = errors.ETLS;
+                    }
+                    callback(err);
+                }, 1000);
+
+                try {
+                    timer.unref();
+                } catch (_E) {
+                    // Ignore. Happens on envs with non-node timer implementation
+                }
+            });
+
+            this.connection.connect(() => {
+                if (returned) {
+                    return;
+                }
+
+                if (this.auth && (this.connection.allowsAuth || options.forceAuth)) {
+                    this.connection.login(this.auth, err => {
+                        if (returned) {
+                            return;
+                        }
+                        returned = true;
+
+                        if (err) {
+                            this.connection.close();
+                            this.emit('error', err);
+                            return callback(err);
+                        }
+
+                        this._connected = true;
+                        callback(null, true);
+                    });
+                } else {
+                    returned = true;
+                    this._connected = true;
+                    return callback(null, true);
+                }
+            });
+        });
+    }
+
+    /**
+     * Sends an e-mail to be sent using the selected settings
+     *
+     * @param {Object} mail Mail object
+     * @param {Function} callback Callback function
+     */
+    send(mail, callback) {
+        if (!this._connected) {
+            return this.connect(err => {
+                if (err) {
+                    return callback(err);
+                }
+                return this.send(mail, callback);
+            });
+        }
+
+        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,
+                cid: this.id
+            },
+            'Sending message %s using #%s to <%s>',
+            messageId,
+            this.id,
+            recipients.join(', ')
+        );
+
+        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.connection.send(envelope, mail.message.createReadStream(), (err, info) => {
+            this.messages++;
+
+            if (err) {
+                this.connection.close();
+                this.emit('error', err);
+                return callback(err);
+            }
+
+            info.envelope = {
+                from: envelope.from,
+                to: envelope.to
+            };
+            info.messageId = messageId;
+
+            setImmediate(() => {
+                if (this.messages >= this.options.maxMessages) {
+                    const err = new Error('Resource exhausted');
+                    err.code = errors.EMAXLIMIT;
+                    this.connection.close();
+                    this.emit('error', err);
+                } else {
+                    this.pool._checkRateLimit(() => {
+                        this.available = true;
+                        this.emit('available');
+                    });
+                }
+            });
+
+            callback(null, info);
+        });
+    }
+
+    /**
+     * Closes the connection
+     */
+    close() {
+        this._connected = false;
+        if (this.auth && this.auth.oauth2) {
+            this.auth.oauth2.removeAllListeners();
+        }
+        if (this.connection) {
+            this.connection.close();
+        }
+        this.emit('close');
+    }
+}
+
+module.exports = PoolResource;

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

@@ -0,0 +1,402 @@
+'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 errors = require('../errors');
+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'
+        });
+
+        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 {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;
+        }
+
+        const authData = Object.assign(
+            {},
+            this.options.auth && typeof this.options.auth === 'object' ? this.options.auth : {},
+            authOpts && 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 {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 = Object.assign(shared.assign(false, options), socketOptions);
+            }
+
+            const connection = new SMTPConnection(options);
+
+            connection.once('error', err => {
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                connection.close();
+                return callback(err);
+            });
+
+            connection.once('end', () => {
+                if (returned) {
+                    return;
+                }
+
+                const timer = setTimeout(() => {
+                    if (returned) {
+                        return;
+                    }
+                    returned = true;
+                    // still have not returned, this means we have an unexpected connection close
+                    const err = new Error('Unexpected socket close');
+                    if (connection && connection._socket && connection._socket.upgrading) {
+                        // starttls connection errors
+                        err.code = errors.ETLS;
+                    }
+                    callback(err);
+                }, 1000);
+
+                try {
+                    timer.unref();
+                } catch (_E) {
+                    // Ignore. Happens on envs with non-node timer implementation
+                }
+            });
+
+            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) => {
+                    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;
+                }
+
+                const 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 = Object.assign(shared.assign(false, options), socketOptions);
+            }
+
+            const 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'));
+            });
+
+            const finalize = () => {
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                connection.quit();
+                return callback(null, true);
+            };
+
+            connection.connect(() => {
+                if (returned) {
+                    return;
+                }
+
+                const 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) {
+                    const err = new Error('Authentication info was not provided');
+                    err.code = errors.ENOAUTH;
+
+                    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;