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

package/dist/node_modules/nodemailer/{lib → dist/esm}/mailer/index.js

@@ -1,94 +1,77 @@
-'use strict';
-
-const EventEmitter = require('events');
-const shared = require('../shared');
-const mimeTypes = require('../mime-funcs/mime-types');
-const MailComposer = require('../mail-composer');
-const DKIM = require('../dkim');
-const httpProxyClient = require('../smtp-connection/http-proxy-client');
-const util = require('util');
-const urllib = require('url');
-const packageData = require('../../package.json');
-const MailMessage = require('./mail-message');
-const net = require('net');
-const dns = require('dns');
-const crypto = require('crypto');
-
+import { EventEmitter } from 'node:events';
+import * as shared from '../shared/index.js';
+import * as mimeTypes from '../mime-funcs/mime-types.js';
+import MailComposer from '../mail-composer/index.js';
+import DKIM from '../dkim/index.js';
+import httpProxyClient from '../smtp-connection/http-proxy-client.js';
+import * as errors from '../errors.js';
+import util from 'node:util';
+import * as urllib from '../shared/url.js';
+import * as packageData from '../package-info.js';
+import MailMessage from './mail-message.js';
+import net from 'node:net';
+import dns from 'node:dns';
+import crypto from 'node:crypto';
+/**
+ * Recipients allowed on one message unless the caller sets its own maxRecipients. A backstop
+ * against a runaway or hostile recipient list rather than a delivery policy: RFC 5321 only
+ * asks a server to accept 100, so a real send is bounded far below this.
+ */
+const DEFAULT_MAX_RECIPIENTS = 100000;
 /**
  * Creates an object for exposing the Mail API
  *
  * @constructor
- * @param {Object} transporter Transport object instance to pass the mails to
+ * @param transporter Transport object instance to pass the mails to
  */
 class Mail extends EventEmitter {
     constructor(transporter, options, defaults) {
         super();
-
         this.options = options || {};
         this._defaults = defaults || {};
-
         this._defaultPlugins = {
             compile: [(...args) => this._convertDataImages(...args)],
             stream: []
         };
-
         this._userPlugins = {
             compile: [],
             stream: []
         };
-
         this.meta = new Map();
-
         this.dkim = this.options.dkim ? new DKIM(this.options.dkim) : false;
-
         this.transporter = transporter;
         this.transporter.mailer = this;
-
         this.logger = shared.getLogger(this.options, {
             component: this.options.component || 'mail'
         });
-
-        this.logger.debug(
-            {
-                tnx: 'create'
-            },
-            'Creating transport: %s',
-            this.getVersionString()
-        );
-
+        this.logger.debug({
+            tnx: 'create'
+        }, 'Creating transport: %s', this.getVersionString());
         // setup emit handlers for the transporter
         if (typeof this.transporter.on === 'function') {
             // deprecated log interface
             this.transporter.on('log', log => {
-                this.logger.debug(
-                    {
-                        tnx: 'transport'
-                    },
-                    '%s: %s',
-                    log.type,
-                    log.message
-                );
+                this.logger.debug({
+                    tnx: 'transport'
+                }, '%s: %s', log.type, log.message);
             });
-
             // transporter errors
             this.transporter.on('error', err => {
-                this.logger.error(
-                    {
-                        err,
-                        tnx: 'transport'
-                    },
-                    'Transport Error: %s',
-                    err.message
-                );
+                this.logger.error({
+                    err,
+                    tnx: 'transport'
+                }, 'Transport Error: %s', err.message);
                 this.emit('error', err);
             });
-
             // indicates if the sender has became idle
             this.transporter.on('idle', (...args) => {
                 this.emit('idle', ...args);
             });
+            // indicates if the sender has became idle and all connections are terminated
+            this.transporter.on('clear', (...args) => {
+                this.emit('clear', ...args);
+            });
         }
-
         /**
          * Optional methods passed to the underlying transport object
          */
@@ -100,186 +83,155 @@ class Mail extends EventEmitter {
                         this.getSocket = false;
                     }
                     return this.transporter[method](...args);
-                } else {
-                    this.logger.warn(
-                        {
-                            tnx: 'transport',
-                            methodName: method
-                        },
-                        'Non existing method %s called for transport',
-                        method
-                    );
-                    return false;
                 }
+                this.logger.warn({
+                    tnx: 'transport',
+                    methodName: method
+                }, 'Non existing method %s called for transport', method);
+                return false;
             };
         });
-
         // setup proxy handling
         if (this.options.proxy && typeof this.options.proxy === 'string') {
             this.setupProxy(this.options.proxy);
         }
     }
-
     use(step, plugin) {
         step = (step || '').toString();
         if (!this._userPlugins.hasOwnProperty(step)) {
             this._userPlugins[step] = [plugin];
-        } else {
+        }
+        else {
             this._userPlugins[step].push(plugin);
         }
-
         return this;
     }
-
-    /**
-     * Sends an email using the preselected transport object
-     *
-     * @param {Object} data E-data description
-     * @param {Function?} callback Callback to run once the sending succeeded or failed
-     */
     sendMail(data, callback = null) {
         let promise;
-
         if (!callback) {
             promise = new Promise((resolve, reject) => {
                 callback = shared.callbackPromise(resolve, reject);
             });
         }
-
+        const done = callback;
         if (typeof this.getSocket === 'function') {
             this.transporter.getSocket = this.getSocket;
             this.getSocket = false;
         }
-
-        let mail = new MailMessage(this, data);
-
-        this.logger.debug(
-            {
-                tnx: 'transport',
-                name: this.transporter.name,
-                version: this.transporter.version,
-                action: 'send'
-            },
-            'Sending mail using %s/%s',
-            this.transporter.name,
-            this.transporter.version
-        );
-
+        const mail = new MailMessage(this, data);
+        this.logger.debug({
+            tnx: 'transport',
+            name: this.transporter.name,
+            version: this.transporter.version,
+            action: 'send'
+        }, 'Sending mail using %s/%s', this.transporter.name, this.transporter.version);
         this._processPlugins('compile', mail, err => {
             if (err) {
-                this.logger.error(
-                    {
-                        err,
-                        tnx: 'plugin',
-                        action: 'compile'
-                    },
-                    'PluginCompile Error: %s',
-                    err.message
-                );
-                return callback(err);
+                this.logger.error({
+                    err,
+                    tnx: 'plugin',
+                    action: 'compile'
+                }, 'PluginCompile Error: %s', err.message);
+                return done(err);
+            }
+            let recipientCount;
+            try {
+                mail.message = new MailComposer(mail.data).compile();
+                mail.setMailerHeader();
+                mail.setPriorityHeaders();
+                mail.setListHeaders();
+                recipientCount = mail.message.getEnvelope().to.length;
+            }
+            catch (err) {
+                // message data can throw while it is compiled, the error belongs to the callback
+                this.logger.error({
+                    err,
+                    tnx: 'transport',
+                    action: 'send'
+                }, 'Compile Error: %s', err.message);
+                return done(err);
+            }
+            const maxRecipients = mail.data.maxRecipients === undefined ? DEFAULT_MAX_RECIPIENTS : mail.data.maxRecipients;
+            if (maxRecipients && recipientCount > maxRecipients) {
+                const err = new Error(`Message has ${recipientCount} recipients, which is over the ${maxRecipients} allowed by maxRecipients`);
+                err.code = errors.EMAXRECIPIENTS;
+                this.logger.error({
+                    err,
+                    tnx: 'transport',
+                    action: 'send'
+                }, 'Send Error: %s', err.message);
+                return done(err);
             }
-
-            mail.message = new MailComposer(mail.data).compile();
-
-            mail.setMailerHeader();
-            mail.setPriorityHeaders();
-            mail.setListHeaders();
-
             this._processPlugins('stream', mail, err => {
                 if (err) {
-                    this.logger.error(
-                        {
-                            err,
-                            tnx: 'plugin',
-                            action: 'stream'
-                        },
-                        'PluginStream Error: %s',
-                        err.message
-                    );
-                    return callback(err);
+                    this.logger.error({
+                        err,
+                        tnx: 'plugin',
+                        action: 'stream'
+                    }, 'PluginStream Error: %s', err.message);
+                    return done(err);
                 }
-
                 if (mail.data.dkim || this.dkim) {
                     mail.message.processFunc(input => {
-                        let dkim = mail.data.dkim ? new DKIM(mail.data.dkim) : this.dkim;
-                        this.logger.debug(
-                            {
-                                tnx: 'DKIM',
-                                messageId: mail.message.messageId(),
-                                dkimDomains: dkim.keys.map(key => key.keySelector + '.' + key.domainName).join(', ')
-                            },
-                            'Signing outgoing message with %s keys',
-                            dkim.keys.length
-                        );
+                        const dkim = mail.data.dkim ? new DKIM(mail.data.dkim) : this.dkim;
+                        this.logger.debug({
+                            tnx: 'DKIM',
+                            messageId: mail.message.messageId(),
+                            dkimDomains: dkim.keys.map(key => key.keySelector + '.' + key.domainName).join(', ')
+                        }, 'Signing outgoing message with %s keys', dkim.keys.length);
                         return dkim.sign(input, mail.data._dkim);
                     });
                 }
-
                 this.transporter.send(mail, (...args) => {
                     if (args[0]) {
-                        this.logger.error(
-                            {
-                                err: args[0],
-                                tnx: 'transport',
-                                action: 'send'
-                            },
-                            'Send Error: %s',
-                            args[0].message
-                        );
+                        this.logger.error({
+                            err: args[0],
+                            tnx: 'transport',
+                            action: 'send'
+                        }, 'Send Error: %s', args[0].message);
                     }
-                    callback(...args);
+                    done(...args);
                 });
             });
         });
-
         return promise;
     }
-
     getVersionString() {
         return util.format('%s (%s; +%s; %s/%s)', packageData.name, packageData.version, packageData.homepage, this.transporter.name, this.transporter.version);
     }
-
+    /** @internal */
     _processPlugins(step, mail, callback) {
         step = (step || '').toString();
-
         if (!this._userPlugins.hasOwnProperty(step)) {
             return callback();
         }
-
-        let userPlugins = this._userPlugins[step] || [];
-        let defaultPlugins = this._defaultPlugins[step] || [];
-
+        const userPlugins = this._userPlugins[step] || [];
+        const defaultPlugins = this._defaultPlugins[step] || [];
         if (userPlugins.length) {
-            this.logger.debug(
-                {
-                    tnx: 'transaction',
-                    pluginCount: userPlugins.length,
-                    step
-                },
-                'Using %s plugins for %s',
-                userPlugins.length,
+            this.logger.debug({
+                tnx: 'transaction',
+                pluginCount: userPlugins.length,
                 step
-            );
+            }, 'Using %s plugins for %s', userPlugins.length, step);
         }
-
         if (userPlugins.length + defaultPlugins.length === 0) {
             return callback();
         }
-
         let pos = 0;
         let block = 'default';
-        let processPlugins = () => {
+        const processPlugins = () => {
             let curplugins = block === 'default' ? defaultPlugins : userPlugins;
             if (pos >= curplugins.length) {
                 if (block === 'default' && userPlugins.length) {
                     block = 'user';
                     pos = 0;
                     curplugins = userPlugins;
-                } else {
+                }
+                else {
                     return callback();
                 }
             }
-            let plugin = curplugins[pos++];
+            const plugin = curplugins[pos++];
             plugin(mail, err => {
                 if (err) {
                     return callback(err);
@@ -287,31 +239,26 @@ class Mail extends EventEmitter {
                 processPlugins();
             });
         };
-
         processPlugins();
     }
-
     /**
      * Sets up proxy handler for a Nodemailer object
      *
-     * @param {String} proxyUrl Proxy configuration url
+     * @param proxyUrl Proxy configuration url
      */
     setupProxy(proxyUrl) {
-        let proxy = urllib.parse(proxyUrl);
-
+        const proxy = urllib.parse(proxyUrl);
         // setup socket handler for the mailer object
         this.getSocket = (options, callback) => {
-            let protocol = proxy.protocol.replace(/:$/, '').toLowerCase();
-
+            const protocol = proxy.protocol.replace(/:$/, '').toLowerCase();
             if (this.meta.has('proxy_handler_' + protocol)) {
                 return this.meta.get('proxy_handler_' + protocol)(proxy, options, callback);
             }
-
             switch (protocol) {
                 // Connect using a HTTP CONNECT method
                 case 'http':
                 case 'https':
-                    httpProxyClient(proxy.href, options.port, options.host, (err, socket) => {
+                    httpProxyClient(proxy.href, options.port, options.host, this.options.tls || {}, (err, socket) => {
                         if (err) {
                             return callback(err);
                         }
@@ -325,13 +272,15 @@ class Mail extends EventEmitter {
                 case 'socks4':
                 case 'socks4a': {
                     if (!this.meta.has('proxy_socks_module')) {
-                        return callback(new Error('Socks module not loaded'));
+                        let err = new Error('Socks module not loaded');
+                        err.code = errors.EPROXY;
+                        return callback(err);
                     }
-                    let connect = ipaddress => {
-                        let proxyV2 = !!this.meta.get('proxy_socks_module').SocksClient;
-                        let socksClient = proxyV2 ? this.meta.get('proxy_socks_module').SocksClient : this.meta.get('proxy_socks_module');
-                        let proxyType = Number(proxy.protocol.replace(/\D/g, '')) || 5;
-                        let connectionOpts = {
+                    const connect = (ipaddress) => {
+                        const proxyV2 = !!this.meta.get('proxy_socks_module').SocksClient;
+                        const socksClient = proxyV2 ? this.meta.get('proxy_socks_module').SocksClient : this.meta.get('proxy_socks_module');
+                        const proxyType = Number(proxy.protocol.replace(/\D/g, '')) || 5;
+                        const connectionOpts = {
                             proxy: {
                                 ipaddress,
                                 port: Number(proxy.port),
@@ -343,23 +292,23 @@ class Mail extends EventEmitter {
                             },
                             command: 'connect'
                         };
-
-                        if (proxy.auth) {
-                            let username = decodeURIComponent(proxy.auth.split(':').shift());
-                            let password = decodeURIComponent(proxy.auth.split(':').pop());
+                        if (proxy.username || proxy.password) {
+                            const username = proxy.username || '';
+                            const password = proxy.password || '';
                             if (proxyV2) {
                                 connectionOpts.proxy.userId = username;
                                 connectionOpts.proxy.password = password;
-                            } else if (proxyType === 4) {
+                            }
+                            else if (proxyType === 4) {
                                 connectionOpts.userid = username;
-                            } else {
+                            }
+                            else {
                                 connectionOpts.authentication = {
                                     username,
                                     password
                                 };
                             }
                         }
-
                         socksClient.createConnection(connectionOpts, (err, info) => {
                             if (err) {
                                 return callback(err);
@@ -369,11 +318,9 @@ class Mail extends EventEmitter {
                             });
                         });
                     };
-
                     if (net.isIP(proxy.hostname)) {
                         return connect(proxy.hostname);
                     }
-
                     return dns.resolve(proxy.hostname, (err, address) => {
                         if (err) {
                             return callback(err);
@@ -382,15 +329,17 @@ class Mail extends EventEmitter {
                     });
                 }
             }
-            callback(new Error('Unknown proxy configuration'));
+            let err = new Error('Unknown proxy configuration');
+            err.code = errors.EPROXY;
+            callback(err);
         };
     }
-
+    /** @internal */
     _convertDataImages(mail, callback) {
         if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) {
             return callback();
         }
-        mail.resolveContent(mail.data, 'html', (err, html) => {
+        mail.resolveContent(mail.data, 'html', { disableFileAccess: mail.data.disableFileAccess, disableUrlAccess: mail.data.disableUrlAccess }, (err, html) => {
             if (err) {
                 return callback(err);
             }
@@ -398,32 +347,29 @@ class Mail extends EventEmitter {
             html = (html || '')
                 .toString()
                 .replace(/(<img\b[^<>]{0,1024} src\s{0,20}=[\s"']{0,20})(data:([^;]+);[^"'>\s]+)/gi, (match, prefix, dataUri, mimeType) => {
-                    let cid = crypto.randomBytes(10).toString('hex') + '@localhost';
-                    if (!mail.data.attachments) {
-                        mail.data.attachments = [];
-                    }
-                    if (!Array.isArray(mail.data.attachments)) {
-                        mail.data.attachments = [].concat(mail.data.attachments || []);
-                    }
-                    mail.data.attachments.push({
-                        path: dataUri,
-                        cid,
-                        filename: 'image-' + ++cidCounter + '.' + mimeTypes.detectExtension(mimeType)
-                    });
-                    return prefix + 'cid:' + cid;
+                const cid = crypto.randomBytes(10).toString('hex') + '@localhost';
+                if (!mail.data.attachments) {
+                    mail.data.attachments = [];
+                }
+                if (!Array.isArray(mail.data.attachments)) {
+                    mail.data.attachments = [].concat(mail.data.attachments || []);
+                }
+                mail.data.attachments.push({
+                    path: dataUri,
+                    cid,
+                    filename: 'image-' + ++cidCounter + '.' + mimeTypes.detectExtension(mimeType)
                 });
+                return prefix + 'cid:' + cid;
+            });
             mail.data.html = html;
             callback();
         });
     }
-
     set(key, value) {
         return this.meta.set(key, value);
     }
-
     get(key) {
         return this.meta.get(key);
     }
 }
-
-module.exports = Mail;
+export default Mail;

package/dist/node_modules/nodemailer/dist/esm/mailer/mail-message.d.ts

@@ -0,0 +1,97 @@
+import MimeNode, { type MimeNodePreparedHeaderValue } from '../mime-node/index.js';
+import type { MailComposerOptions } from '../mail-composer/index.js';
+import type { DKIMOptions } from '../dkim/index.js';
+import type { SMTPEnvelopeDsn } from '../smtp-connection/index.js';
+import type { SMTPTransportAuthOptions } from '../smtp-transport/index.js';
+import type { SESSendEmailRequest } from '../ses-transport/index.js';
+import type { NodemailerError } from '../errors.js';
+import type { ResolveContentOptions } from '../shared/index.js';
+import type Mail from './index.js';
+import type { SentMessageInfo } from './index.js';
+/**
+ * The message data accepted by sendMail. MailComposerOptions describes the fields the MIME
+ * tree is built from, the fields below are the ones the mailer reads on top of those
+ */
+export interface SendMailOptions extends MailComposerOptions {
+    /** DKIM signing options for this message, used instead of the ones of the transporter */
+    dkim?: DKIMOptions | undefined;
+    /** Extra DKIM options for this message, merged over the options of the signer. The SES transport sets skipFields here, the option is not meant for callers */
+    _dkim?: DKIMOptions | undefined;
+    /** Recipients allowed on this message, 0 disables the limit, defaults to 100000 */
+    maxRecipients?: number | undefined;
+    /** SMTP transports: DSN parameters for the envelope, sent when the server supports the DSN extension */
+    dsn?: SMTPEnvelopeDsn | undefined;
+    /** SMTP transports: RFC 8689, send the REQUIRETLS parameter with MAIL FROM */
+    requireTLSExtensionEnabled?: boolean | undefined;
+    /** SMTP transports: per-message authentication settings, used instead of the transport level auth */
+    auth?: SMTPTransportAuthOptions | undefined;
+    /** SES transport: extra SendEmailCommand parameters merged into the API call */
+    ses?: SESSendEmailRequest | undefined;
+}
+/**
+ * Default message fields, the third argument of createTransport. Applied to every message
+ * for the fields the message does not set itself, the headers are merged one by one
+ */
+export type MailDefaults = SendMailOptions;
+/**
+ * The message data as held by a MailMessage: the options the caller passed to sendMail with
+ * the transporter defaults applied. resolveAll rewrites the content and address fields in
+ * place and normalize adds the envelope, the Message-ID and the normalized headers
+ */
+export interface MailMessageData extends SendMailOptions {
+    /** Header values flattened to strings and keyed by lowercase header name, set by normalize */
+    normalizedHeaders?: {
+        [key: string]: string;
+    } | undefined;
+}
+/**
+ * Callback for resolveAll and normalize, receives the message data with every content value
+ * resolved
+ */
+export type MailMessageDataCallback = (err: NodemailerError | null, data: MailMessageData) => void;
+/**
+ * Callback for resolveContent, receives the resolved content value
+ */
+export type MailMessageContentCallback = (err: NodemailerError | null, value?: any) => void;
+/**
+ * A single prepared List-* header value, emitted as is
+ */
+export interface MailMessageListHeaderValue extends MimeNodePreparedHeaderValue {
+    prepared: boolean;
+    foldLines: boolean;
+    value: string;
+}
+/**
+ * A List-* header as built from the list value, one prepared value per list entry
+ */
+export interface MailMessageListHeader {
+    /** Header key, 'list-' followed by the lowercase list key */
+    key: string;
+    value: MailMessageListHeaderValue[];
+}
+export default class MailMessage<T = SentMessageInfo> {
+    mailer: Mail<T>;
+    data: MailMessageData;
+    /**
+     * The compiled MIME tree. Set once the compile step is done, so it is null while the
+     * 'compile' plugins run and set by the time the 'stream' plugins and the transport see
+     * the message. Declared as always set, the way @types/nodemailer declared it, since the
+     * plugins that read it are the ones that run after it is set
+     */
+    message: MimeNode;
+    constructor(mailer: Mail<T>, data?: SendMailOptions);
+    resolveContent(data: {
+        [key: string]: any;
+    }, key: string | number, callback: MailMessageContentCallback): void;
+    resolveContent(data: {
+        [key: string]: any;
+    }, key: string | number, options: ResolveContentOptions | false | undefined, callback: MailMessageContentCallback): void;
+    resolveContent(data: {
+        [key: string]: any;
+    }, key: string | number, options?: ResolveContentOptions | false): Promise<any>;
+    resolveAll(callback: MailMessageDataCallback): void;
+    normalize(callback: MailMessageDataCallback): void;
+    setMailerHeader(): void;
+    setPriorityHeaders(): void;
+    setListHeaders(): void;
+}