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

package/dist/node_modules/nodemailer/dist/cjs/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/dist/cjs/smtp-pool/pool-resource.js

@@ -0,0 +1,257 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = __importDefault(require("../smtp-connection/index.js"));
+const index_js_2 = require("../shared/index.js");
+const index_js_3 = __importDefault(require("../xoauth2/index.js"));
+const errors = __importStar(require("../errors.js"));
+const node_events_1 = require("node:events");
+/**
+ * Creates an element for the pool
+ *
+ * @constructor
+ * @param pool SMTPPool instance
+ */
+class PoolResource extends node_events_1.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 index_js_3.default(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._fail(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;
+        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 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 = Object.assign((0, index_js_2.assign)(false, options), socketOptions);
+            }
+            this.connection = new index_js_1.default(options);
+            this.connection.on('error', err => {
+                this._fail(err);
+                if (returned) {
+                    return;
+                }
+                returned = true;
+                return callback(err);
+            });
+            this.connection.once('end', () => {
+                this.close();
+                returned = true;
+            });
+            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._fail(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 mail Mail object
+     * @param 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._fail(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._fail(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');
+    }
+}
+exports.default = PoolResource;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/node_modules/nodemailer/dist/cjs/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;