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

package/dist/node_modules/nodemailer/dist/esm/smtp-pool/pool-resource.d.ts

@@ -0,0 +1,62 @@
+import SMTPConnection from '../smtp-connection/index.js';
+import { type Logger } from '../shared/index.js';
+import { EventEmitter } from 'node:events';
+import type { SMTPTransportAuth, SMTPTransportSendCallback } from '../smtp-transport/index.js';
+import type MailMessage from '../mailer/mail-message.js';
+import type SMTPPool from './index.js';
+import type { SMTPPoolResolvedOptions, SMTPPoolQueueEntry } from './index.js';
+/**
+ * Callback for connect(), the result is true once the connection is ready for messages
+ */
+export type PoolResourceConnectCallback = (err: Error | null, connected?: true) => void;
+/**
+ * Callback for send()
+ */
+export type PoolResourceSendCallback = SMTPTransportSendCallback;
+/**
+ * Creates an element for the pool
+ *
+ * @constructor
+ * @param pool SMTPPool instance
+ */
+export default class PoolResource extends EventEmitter {
+    pool: SMTPPool;
+    options: SMTPPoolResolvedOptions;
+    logger: Logger;
+    /**
+     * Authentication data for the connection, set when the pool options include auth
+     */
+    auth?: SMTPTransportAuth | undefined;
+    messages: number;
+    available: boolean;
+    /**
+     * The SMTP connection, set by connect()
+     */
+    connection: SMTPConnection;
+    /**
+     * Resource id, assigned by the pool
+     */
+    id: number;
+    /**
+     * The queue entry being sent, assigned by the pool. False once it has been handled
+     */
+    queueEntry?: SMTPPoolQueueEntry | false | undefined;
+    constructor(pool: SMTPPool);
+    /**
+     * Initiates a connection to the SMTP server
+     *
+     * @param callback Callback function to run once the connection is established or failed
+     */
+    connect(callback: PoolResourceConnectCallback): void;
+    /**
+     * Sends an e-mail to be sent using the selected settings
+     *
+     * @param mail Mail object
+     * @param callback Callback function
+     */
+    send(mail: MailMessage, callback: PoolResourceSendCallback): void;
+    /**
+     * Closes the connection
+     */
+    close(): void;
+}

package/dist/node_modules/nodemailer/{lib → dist/esm}/smtp-pool/pool-resource.js

@@ -1,37 +1,34 @@
-'use strict';
-
-const SMTPConnection = require('../smtp-connection');
-const assign = require('../shared').assign;
-const XOAuth2 = require('../xoauth2');
-const EventEmitter = require('events');
-
+import SMTPConnection from '../smtp-connection/index.js';
+import { assign } from '../shared/index.js';
+import XOAuth2 from '../xoauth2/index.js';
+import * as errors from '../errors.js';
+import { EventEmitter } from 'node:events';
 /**
  * Creates an element for the pool
  *
  * @constructor
- * @param {Object} options SMTPPool instance
+ * @param pool SMTPPool instance
  */
-class PoolResource extends EventEmitter {
+export default 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': {
-                    let oauth2 = new XOAuth2(this.options.auth, this.logger);
-                    oauth2.provisionCallback = (this.pool.mailer && this.pool.mailer.get('oauth2_provision_cb')) || oauth2.provisionCallback;
+                    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));
+                    oauth2.on('token', (token) => this.pool.mailer.emit('token', token));
+                    oauth2.on('error', err => this._fail(err));
                     break;
                 }
                 default:
@@ -50,110 +47,90 @@ class PoolResource extends EventEmitter {
                     };
             }
         }
-
         this._connection = false;
         this._connected = false;
-
         this.messages = 0;
         this.available = true;
+        this._failed = false;
+    }
+    /**
+     * Emits 'error' for the first failure only. A dead resource can report the same failure more
+     * than once (the connection error, then the send callback), the pool handles it once
+     * @internal
+     */
+    _fail(err) {
+        if (this._failed) {
+            return;
+        }
+        this._failed = true;
+        this.emit('error', err);
     }
-
     /**
      * Initiates a connection to the SMTP server
      *
-     * @param {Function} callback Callback function to run once the connection is established or failed
+     * @param callback Callback function to run once the connection is established or failed
      */
     connect(callback) {
         this.pool.getSocket(this.options, (err, socketOptions) => {
             if (err) {
+                // nothing was connected, so no 'close' event is coming that would free the
+                // slot this resource holds in the pool, report the failure the way a failed
+                // login does
+                this._fail(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 = assign(false, options);
-                Object.keys(socketOptions).forEach(key => {
-                    options[key] = socketOptions[key];
-                });
+                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);
+            this.connection.on('error', err => {
+                this._fail(err);
                 if (returned) {
                     return;
                 }
                 returned = true;
                 return callback(err);
             });
-
             this.connection.once('end', () => {
                 this.close();
-                if (returned) {
-                    return;
-                }
                 returned = true;
-
-                let timer = setTimeout(() => {
-                    if (returned) {
-                        return;
-                    }
-                    // still have not returned, this means we have an unexpected connection close
-                    let err = new Error('Unexpected socket close');
-                    if (this.connection && this.connection._socket && this.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
-                }
             });
-
-            this.connection.connect(() => {
+            this.connection.connect(err => {
                 if (returned) {
                     return;
                 }
-
+                if (err) {
+                    // a close before the greeting, the 'end' that follows closes this resource
+                    // and the pool requeues or fails the entry, bounded by maxRequeues
+                    returned = true;
+                    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);
+                            this._fail(err);
                             return callback(err);
                         }
-
                         this._connected = true;
                         callback(null, true);
                     });
-                } else {
+                }
+                else {
                     returned = true;
                     this._connected = true;
                     return callback(null, true);
@@ -161,12 +138,11 @@ class PoolResource extends EventEmitter {
             });
         });
     }
-
     /**
      * Sends an e-mail to be sent 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) {
         if (!this._connected) {
@@ -177,64 +153,53 @@ class PoolResource extends EventEmitter {
                 return this.send(mail, callback);
             });
         }
-
-        let envelope = mail.message.getEnvelope();
-        let messageId = mail.message.messageId();
-
-        let recipients = [].concat(envelope.to || []);
+        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>',
+        this.logger.info({
+            tnx: 'send',
             messageId,
-            this.id,
-            recipients.join(', ')
-        );
-
+            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);
+                this._fail(err);
                 return callback(err);
             }
-
             info.envelope = {
                 from: envelope.from,
                 to: envelope.to
             };
             info.messageId = messageId;
-
             setImmediate(() => {
-                let err;
                 if (this.messages >= this.options.maxMessages) {
-                    err = new Error('Resource exhausted');
-                    err.code = 'EMAXLIMIT';
+                    const err = new Error('Resource exhausted');
+                    err.code = errors.EMAXLIMIT;
                     this.connection.close();
-                    this.emit('error', err);
-                } else {
+                    this._fail(err);
+                }
+                else {
                     this.pool._checkRateLimit(() => {
                         this.available = true;
                         this.emit('available');
                     });
                 }
             });
-
             callback(null, info);
         });
     }
-
     /**
      * Closes the connection
      */
@@ -249,5 +214,3 @@ class PoolResource extends EventEmitter {
         this.emit('close');
     }
 }
-
-module.exports = PoolResource;

package/dist/node_modules/nodemailer/dist/esm/smtp-transport/index.d.ts

@@ -0,0 +1,156 @@
+import { EventEmitter } from 'node:events';
+import { type SMTPConnectionOptions, type SMTPConnectionAuth, type SMTPConnectionSendInfo } from '../smtp-connection/index.js';
+import * as shared from '../shared/index.js';
+import { type XOAuth2Options } from '../xoauth2/index.js';
+import type { ResultCallback } from '../errors.js';
+import type MailMessage from '../mailer/mail-message.js';
+import type { default as Mail, GetSocketCallback, SentMessageInfo, SendMailOptions, TransportOptions, VerifyCallback } from '../mailer/index.js';
+import type { MimeNodeEnvelope } from '../mime-node/index.js';
+/**
+ * Authentication settings, either from the transport options or from the message data.
+ * OAuth2 settings are handed to XOAuth2 as is
+ */
+export interface SMTPTransportAuthOptions extends XOAuth2Options {
+    /** 'OAuth2' selects XOAUTH2, anything else is a password login, 'LOGIN' when not set */
+    type?: string | undefined;
+    /** Username */
+    user?: string | undefined;
+    /** Password */
+    pass?: string | undefined;
+    /** SASL method to use, e.g. 'PLAIN', 'LOGIN' or 'CRAM-MD5' */
+    method?: string | undefined;
+    /** Extra options for the authentication method, handed to a custom SASL handler */
+    options?: {
+        [key: string]: any;
+    } | undefined;
+    /** Service identifier, an OAuth2 login needs either this or a user */
+    service?: string | undefined;
+}
+/**
+ * Authentication data built by getAuth() and handed to SMTPConnection#login
+ */
+export interface SMTPTransportAuth extends SMTPConnectionAuth {
+    /** 'OAUTH2', or the upper cased type from the settings, 'LOGIN' when none was given */
+    type: string;
+    /** 'XOAUTH2' for OAuth2, otherwise the configured SASL method, false lets the connection pick one */
+    method: string | false;
+}
+/**
+ * Receives the socket details from getSocket, false when a new socket should be opened. The
+ * object is merged into the connection options, a proxy handler provides the connected socket
+ * as `connection`. The same callback type Mail hands to a transport, so that the SMTP
+ * transports stay assignable to the Transport interface
+ */
+export type SMTPTransportGetSocketCallback = GetSocketCallback;
+/**
+ * Custom socket provider, replaces the getSocket method of the transport
+ */
+export type SMTPTransportGetSocket = (options: SMTPTransportOptions, callback: SMTPTransportGetSocketCallback) => void;
+/**
+ * Options for the SMTP transport, the connection options plus the transport level settings
+ */
+export interface SMTPTransportOptions extends SMTPConnectionOptions, TransportOptions {
+    /** Well-known service name, e.g. 'Gmail', fills in host, port and secure */
+    service?: string | undefined;
+    /** Connection url, e.g. 'smtps://user:pass@smtp.example.com', parsed into options */
+    url?: string | undefined;
+    /** Authentication settings, no authentication when not set */
+    auth?: SMTPTransportAuthOptions | undefined;
+    /** Custom socket provider, e.g. for connecting through a proxy, replaces the getSocket method */
+    getSocket?: SMTPTransportGetSocket | undefined;
+    /** Authenticate even when the server does not advertise AUTH, and fail verify() when it does but no credentials were given */
+    forceAuth?: boolean | undefined;
+    /** Default SASL method for the password logins when the auth settings do not name one */
+    authMethod?: string | undefined;
+    /** Logger component name, defaults to 'smtp-transport' */
+    component?: string | undefined;
+    /** Set to true to get a pooled transport from createTransport, this transport does not read it */
+    pool?: boolean | undefined;
+}
+/**
+ * Result of a sent message, the connection result plus the envelope and the Message-ID
+ */
+export interface SMTPSentMessageInfo extends SMTPConnectionSendInfo, SentMessageInfo {
+    /** Envelope the message was sent with */
+    envelope: MimeNodeEnvelope;
+    /** Message-ID value of the sent message */
+    messageId: string;
+    /** Recipients the server accepted */
+    accepted: string[];
+    /** Recipients the server rejected */
+    rejected: string[];
+    /** Final server response for the message */
+    response: string;
+}
+/**
+ * Callback for send()
+ */
+export type SMTPTransportSendCallback = ResultCallback<SMTPSentMessageInfo>;
+/**
+ * Creates a SMTP transport object for Nodemailer
+ *
+ * @constructor
+ * @param options Connection options
+ */
+declare class SMTPTransport extends EventEmitter {
+    options: SMTPTransportOptions;
+    logger: shared.Logger;
+    name: string;
+    version: string;
+    /**
+     * Transport level authentication data, set when the options include auth
+     */
+    auth?: SMTPTransportAuth | false | undefined;
+    /**
+     * The Mail instance using this transport, assigned by Mail
+     */
+    mailer?: Mail<SMTPSentMessageInfo, SMTPTransportOptions> | undefined;
+    constructor(options?: SMTPTransportOptions | string);
+    /**
+     * 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: SMTPTransportOptions, callback: SMTPTransportGetSocketCallback): void;
+    getAuth(authOpts?: SMTPTransportAuthOptions | false | null): SMTPTransportAuth | false | undefined;
+    /**
+     * Sends an e-mail using the selected settings
+     *
+     * @param mail Mail object
+     * @param callback Callback function
+     */
+    send(mail: MailMessage<SMTPSentMessageInfo>, callback: SMTPTransportSendCallback): void;
+    /**
+     * Verifies SMTP configuration
+     *
+     * @returns Promise that resolves to true if the configuration is usable
+     */
+    verify(): Promise<true>;
+    /**
+     * Verifies SMTP configuration
+     *
+     * @param callback Callback function
+     */
+    verify(callback: VerifyCallback): void;
+    /**
+     * Releases resources
+     */
+    close(): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `SMTPTransport.Options` style references keep working
+ */
+declare namespace SMTPTransport {
+    type Options = SMTPTransportOptions;
+    type MailOptions = SendMailOptions;
+    type SentMessageInfo = SMTPSentMessageInfo;
+    type AuthenticationType = SMTPTransportAuth;
+    type AuthenticationTypeLogin = SMTPTransportAuth;
+    type AuthenticationTypeOAuth2 = SMTPTransportAuth;
+    type AuthenticationTypeCustom = SMTPTransportAuth;
+}
+/** The same aliases as module level exports, for `import * as SMTPTransport` and `import SMTPTransport = require()` */
+export type { SMTPTransportOptions as Options, SendMailOptions as MailOptions, SMTPSentMessageInfo as SentMessageInfo, SMTPTransportAuth as AuthenticationType, SMTPTransportAuth as AuthenticationTypeLogin, SMTPTransportAuth as AuthenticationTypeOAuth2, SMTPTransportAuth as AuthenticationTypeCustom };
+export default SMTPTransport;