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

package/dist/node_modules/nodemailer/{lib → dist/esm}/smtp-transport/index.js

@@ -1,74 +1,59 @@
-'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');
-
+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 {Object} options Connection options
+ * @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.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
+     * @param options Connection options
+     * @param callback Callback function to run with the socket keys
      */
     getSocket(options, callback) {
         // return immediatelly
-        return setImmediate(() => callback(null, false));
+        setImmediate(() => callback(null, false));
     }
-
     getAuth(authOpts) {
         if (!authOpts) {
             if (this.auth && this.auth.oauth2 && this.mailer) {
@@ -79,17 +64,10 @@ class SMTPTransport extends EventEmitter {
             }
             return this.auth;
         }
-
-        const authData = Object.assign(
-            {},
-            this.options.auth && typeof this.options.auth === 'object' ? this.options.auth : {},
-            typeof authOpts === 'object' ? authOpts : {}
-        );
-
+        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) {
@@ -97,7 +75,7 @@ class SMTPTransport extends EventEmitter {
                 }
                 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('token', (token) => this.mailer.emit('token', token));
                 oauth2.on('error', err => this.emit('error', err));
                 return {
                     type: 'OAUTH2',
@@ -119,44 +97,32 @@ class SMTPTransport extends EventEmitter {
                 };
         }
     }
-
     /**
      * Sends an e-mail using the selected settings
      *
-     * @param {Object} mail Mail object
-     * @param {Function} callback Callback function
+     * @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 || ''
-                );
-
+                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) {
@@ -164,7 +130,6 @@ class SMTPTransport extends EventEmitter {
                 }
                 perCallAuth = null;
             };
-
             connection.once('error', err => {
                 if (returned) {
                     return;
@@ -174,76 +139,37 @@ class SMTPTransport extends EventEmitter {
                 connection.close();
                 return callback(err);
             });
-
-            connection.once('end', () => {
-                if (returned) {
-                    return;
-                }
-
-                const timer = setTimeout(() => {
-                    if (returned) {
-                        return;
-                    }
-                    returned = true;
-                    cleanupPerCallAuth();
-                    // 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(', ')
-                );
-
+                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
-                        );
+                        this.logger.error({
+                            err,
+                            tnx: 'send'
+                        }, 'Send error for %s: %s', messageId, err.message);
                         return callback(err);
                     }
                     info.envelope = {
@@ -253,89 +179,71 @@ class SMTPTransport extends EventEmitter {
                     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
-                        );
+                    }
+                    catch (E) {
+                        this.logger.error({
+                            err: E,
+                            tnx: 'callback'
+                        }, 'Callback error for %s: %s', messageId, E.message);
                     }
                 });
             };
-
-            connection.connect(() => {
+            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 {
+                }
+                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);
             });
         }
-
+        // the error paths hand over the error alone
+        const done = callback;
         this.getSocket(this.options, (err, socketOptions) => {
             if (err) {
-                return callback(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 || ''
-                );
-
+                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;
@@ -345,7 +253,6 @@ class SMTPTransport extends EventEmitter {
                 }
                 perCallAuth = null;
             };
-
             connection.once('error', err => {
                 if (returned) {
                     return;
@@ -353,18 +260,16 @@ class SMTPTransport extends EventEmitter {
                 returned = true;
                 cleanupPerCallAuth();
                 connection.close();
-                return callback(err);
+                return done(err);
             });
-
             connection.once('end', () => {
                 if (returned) {
                     return;
                 }
                 returned = true;
                 cleanupPerCallAuth();
-                return callback(new Error('Connection closed'));
+                return done(new Error('Connection closed'));
             });
-
             const finalize = () => {
                 if (returned) {
                     return;
@@ -372,48 +277,47 @@ class SMTPTransport extends EventEmitter {
                 returned = true;
                 cleanupPerCallAuth();
                 connection.quit();
-                return callback(null, true);
+                return done(null, true);
             };
-
-            connection.connect(() => {
+            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 callback(err);
+                            return done(err);
                         }
-
                         finalize();
                     });
-                } else if (!perCallAuth && connection.allowsAuth && options.forceAuth) {
+                }
+                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 callback(err);
-                } else {
+                    return done(err);
+                }
+                else {
                     finalize();
                 }
             });
         });
-
         return promise;
     }
-
     /**
      * Releases resources
      */
@@ -424,6 +328,4 @@ class SMTPTransport extends EventEmitter {
         this.emit('close');
     }
 }
-
-// expose to the world
-module.exports = SMTPTransport;
+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;