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

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

@@ -1,18 +1,18 @@
-'use strict';
-
-const http = require('http');
-const https = require('https');
-const urllib = require('../shared/url');
-const zlib = require('zlib');
-const { PassThrough } = require('stream');
-const Cookies = require('./cookies');
-const packageData = require('../../package.json');
-const net = require('net');
-const errors = require('../errors');
-const { isProtoKey } = require('../shared/objects');
-
+import http from 'node:http';
+import https from 'node:https';
+import * as urllib from '../shared/url.js';
+import zlib from 'node:zlib';
+import { PassThrough } from 'node:stream';
+import Cookies from './cookies.js';
+import * as packageData from '../package-info.js';
+import net from 'node:net';
+import * as errors from '../errors.js';
+import { isProtoKey } from '../shared/objects.js';
 const MAX_REDIRECTS = 5;
-
+// a stalled server would otherwise hold the request, and whatever waits on it, open forever
+const DEFAULT_TIMEOUT = 60 * 1000;
+// the body is usually buffered in memory by the caller, so an unbounded download is refused
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
 // Only genuine TLS settings are taken from options.tls. That object reaches us straight
 // from a user supplied attachment (content.tls), so keys like host, port, path, socketPath
 // or lookup would otherwise repoint the request at a destination that never went through
@@ -43,7 +43,6 @@ const TLS_OPTION_KEYS = [
     'sessionIdContext',
     'sigalgs'
 ];
-
 /**
  * Resolves a URL only if it is one this module is willing to request.
  *
@@ -52,41 +51,30 @@ const TLS_OPTION_KEYS = [
  * or from a redirect Location header. An uncaught throw here takes the process down,
  * so a URL that does not parse is reported the same way as one with a scheme we refuse.
  *
- * @param {String} url URL to parse
- * @returns {Object|Boolean} Parsed URL, or false if it is not a usable http(s) URL
+ * @param url URL to parse
+ * @returns Parsed URL, or false if it is not a usable http(s) URL
  */
 function parseFetchUrl(url) {
     let parsed;
     try {
         parsed = urllib.parse(url);
-    } catch (_err) {
+    }
+    catch (_err) {
         return false;
     }
-
     if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
         return false;
     }
-
     return parsed;
 }
-
-module.exports = function (url, options) {
-    return nmfetch(url, options);
-};
-
-module.exports.Cookies = Cookies;
-
 function nmfetch(url, options) {
     options = options || {};
-
     options.fetchRes = options.fetchRes || new PassThrough();
     options.cookies = options.cookies || new Cookies();
     options.redirects = options.redirects || 0;
     options.maxRedirects = isNaN(options.maxRedirects) ? MAX_REDIRECTS : options.maxRedirects;
-
     const fetchRes = options.fetchRes;
     const parsed = parseFetchUrl(url);
-
     if (!parsed) {
         // Only http(s) URLs can be fetched. Any other scheme (file:, gopher:, a
         // protocol-relative redirect target etc.) would otherwise be silently served over
@@ -107,26 +95,21 @@ function nmfetch(url, options) {
         });
         return fetchRes;
     }
-
     if (options.cookie) {
         [].concat(options.cookie || []).forEach(cookie => {
             options.cookies.set(cookie, url);
         });
         options.cookie = false;
     }
-
     let method = (options.method || '').toString().trim().toUpperCase() || 'GET';
     let finished = false;
     let cookies;
     let body;
-
     const handler = parsed.protocol === 'https:' ? https : http;
-
     const headers = {
         'accept-encoding': 'gzip,deflate',
         'user-agent': 'nodemailer/' + packageData.version
     };
-
     Object.keys(options.headers || {}).forEach(key => {
         // options.headers is the caller's httpHeaders, straight off an attachment
         if (isProtoKey(key.toLowerCase().trim())) {
@@ -134,29 +117,24 @@ function nmfetch(url, options) {
         }
         headers[key.toLowerCase().trim()] = options.headers[key];
     });
-
     if (options.userAgent) {
         headers['user-agent'] = options.userAgent;
     }
-
     if (parsed.auth) {
         headers.Authorization = 'Basic ' + Buffer.from(parsed.auth).toString('base64');
     }
-
     if ((cookies = options.cookies.get(url))) {
         headers.cookie = cookies;
     }
-
     if (options.body) {
         if (options.contentType !== false) {
             headers['Content-Type'] = options.contentType || 'application/x-www-form-urlencoded';
         }
-
         if (typeof options.body.pipe === 'function') {
             // it's a stream
             headers['Transfer-Encoding'] = 'chunked';
             body = options.body;
-            body.on('error', err => {
+            body.on('error', (err) => {
                 if (finished) {
                     return;
                 }
@@ -165,41 +143,41 @@ function nmfetch(url, options) {
                 err.sourceUrl = url;
                 fetchRes.emit('error', err);
             });
-        } else {
+        }
+        else {
             if (options.body instanceof Buffer) {
                 body = options.body;
-            } else if (typeof options.body === 'object') {
+            }
+            else if (typeof options.body === 'object') {
                 try {
                     // encodeURIComponent can fail on invalid input (partial emoji etc.)
-                    body = Buffer.from(
-                        Object.keys(options.body)
-                            .map(key => {
-                                const value = options.body[key].toString().trim();
-                                return encodeURIComponent(key) + '=' + encodeURIComponent(value);
-                            })
-                            .join('&')
-                    );
-                } catch (E) {
-                    if (finished) {
-                        return;
-                    }
+                    body = Buffer.from(Object.keys(options.body)
+                        .map(key => {
+                        const value = options.body[key].toString().trim();
+                        return encodeURIComponent(key) + '=' + encodeURIComponent(value);
+                    })
+                        .join('&'));
+                }
+                catch (E) {
+                    // the caller attaches its error listener once nmfetch has returned, so
+                    // the error is emitted on the next tick and the stream is handed back
+                    // the way every other failure is reported
                     finished = true;
                     E.code = errors.EFETCH;
                     E.sourceUrl = url;
-                    fetchRes.emit('error', E);
-                    return;
+                    setImmediate(() => fetchRes.emit('error', E));
+                    return fetchRes;
                 }
-            } else {
+            }
+            else {
                 body = Buffer.from(options.body.toString().trim());
             }
-
             headers['Content-Type'] = options.contentType || 'application/x-www-form-urlencoded';
             headers['Content-Length'] = body.length;
         }
         // if method is not provided, use POST instead of GET
         method = (options.method || '').toString().trim().toUpperCase() || 'POST';
     }
-
     let req;
     const reqOptions = {
         method,
@@ -213,7 +191,6 @@ function nmfetch(url, options) {
         rejectUnauthorized: true,
         agent: false
     };
-
     if (options.tls) {
         // see TLS_OPTION_KEYS
         Object.keys(options.tls).forEach(key => {
@@ -222,20 +199,17 @@ function nmfetch(url, options) {
             }
         });
     }
-
-    if (
-        parsed.protocol === 'https:' &&
+    if (parsed.protocol === 'https:' &&
         parsed.hostname &&
         parsed.hostname !== reqOptions.host &&
         !net.isIP(parsed.hostname) &&
-        !reqOptions.servername
-    ) {
+        !reqOptions.servername) {
         reqOptions.servername = parsed.hostname;
     }
-
     try {
         req = handler.request(reqOptions);
-    } catch (E) {
+    }
+    catch (E) {
         finished = true;
         setImmediate(() => {
             E.code = errors.EFETCH;
@@ -244,91 +218,64 @@ function nmfetch(url, options) {
         });
         return fetchRes;
     }
-
-    if (options.timeout) {
-        req.setTimeout(options.timeout, () => {
-            if (finished) {
-                return;
-            }
-            finished = true;
-            req.abort();
-            const err = new Error('Request Timeout');
-            err.code = errors.EFETCH;
-            err.sourceUrl = url;
-            fetchRes.emit('error', err);
-        });
-    }
-
-    req.on('error', err => {
+    // reports the first failure of this request on fetchRes and releases the request
+    const fail = (err, sourceUrl = url) => {
         if (finished) {
             return;
         }
         finished = true;
         err.code = errors.EFETCH;
-        err.sourceUrl = url;
+        err.sourceUrl = sourceUrl;
         fetchRes.emit('error', err);
-    });
-
+        req.abort();
+    };
+    const timeout = typeof options.timeout === 'number' && options.timeout >= 0 ? options.timeout : DEFAULT_TIMEOUT;
+    if (timeout) {
+        req.setTimeout(timeout, () => fail(new Error('Request Timeout')));
+    }
+    req.on('error', (err) => fail(err));
     req.on('response', res => {
         let inflate;
-
         if (finished) {
             return;
         }
-
         switch (res.headers['content-encoding']) {
             case 'gzip':
             case 'deflate':
                 inflate = zlib.createUnzip();
                 break;
         }
-
         if (res.headers['set-cookie']) {
             [].concat(res.headers['set-cookie'] || []).forEach(cookie => {
                 options.cookies.set(cookie, url);
             });
         }
-
         if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
             // redirect
             options.redirects++;
             if (options.redirects > options.maxRedirects) {
-                finished = true;
-                const err = new Error('Maximum redirect count exceeded');
-                err.code = errors.EFETCH;
-                err.sourceUrl = url;
-                fetchRes.emit('error', err);
-                req.abort();
-                return;
+                return fail(new Error('Maximum redirect count exceeded'));
             }
             // redirect does not include POST body
             options.method = 'GET';
             options.body = false;
-
             let redirectUrl;
             try {
                 redirectUrl = urllib.resolve(url, res.headers.location);
-            } catch (_err) {
+            }
+            catch (_err) {
                 // the legacy resolver throws on a Location the WHATWG parser also refused,
                 // so fall through to the check below with what the server actually sent
                 redirectUrl = res.headers.location;
             }
             const redirectParsed = parseFetchUrl(redirectUrl);
-
             if (!redirectParsed) {
                 // Refuse the redirect target here rather than leaving it to the recursive
                 // call: that call gets its own `finished` flag and no handle on this
                 // request, so this one would stay open and could emit a second error on
                 // the shared fetchRes once it times out. Callers listen with req.once().
-                finished = true;
-                const err = new Error('Unsupported protocol for URL ' + redirectUrl);
-                err.code = errors.EFETCH;
-                err.sourceUrl = redirectUrl;
-                fetchRes.emit('error', err);
-                req.abort();
-                return;
+                return fail(new Error('Unsupported protocol for URL ' + redirectUrl), redirectUrl);
             }
-
             // Do not forward credentials when the redirect leaves the original
             // security context: a different host, or a downgrade from https to
             // http (which would otherwise put them on the wire in cleartext).
@@ -344,51 +291,38 @@ function nmfetch(url, options) {
                     }
                 });
             }
-
+            // this request is done with, release it so its socket and timeout do not
+            // outlive it and report a late error on the shared fetchRes
+            finished = true;
+            res.resume();
+            req.abort();
             return nmfetch(redirectUrl, options);
         }
-
         fetchRes.statusCode = res.statusCode;
         fetchRes.headers = res.headers;
-
         if (res.statusCode >= 300 && !options.allowErrorResponse) {
-            finished = true;
-            const err = new Error('Invalid status code ' + res.statusCode);
-            err.code = errors.EFETCH;
-            err.sourceUrl = url;
-            fetchRes.emit('error', err);
-            req.abort();
-            return;
+            return fail(new Error('Invalid status code ' + res.statusCode));
         }
-
-        res.on('error', err => {
-            if (finished) {
+        res.on('error', (err) => fail(err));
+        const maxBytes = typeof options.maxBytes === 'number' && options.maxBytes > 0 ? options.maxBytes : DEFAULT_MAX_BYTES;
+        const source = inflate || res;
+        let received = 0;
+        source.on('data', (chunk) => {
+            received += chunk.length;
+            if (received <= maxBytes || finished) {
                 return;
             }
-            finished = true;
-            err.code = errors.EFETCH;
-            err.sourceUrl = url;
-            fetchRes.emit('error', err);
-            req.abort();
+            source.unpipe(fetchRes);
+            fail(new Error('Response size exceeds the allowed ' + maxBytes + ' bytes'));
         });
-
         if (inflate) {
             res.pipe(inflate).pipe(fetchRes);
-            inflate.on('error', err => {
-                if (finished) {
-                    return;
-                }
-                finished = true;
-                err.code = errors.EFETCH;
-                err.sourceUrl = url;
-                fetchRes.emit('error', err);
-                req.abort();
-            });
-        } else {
+            inflate.on('error', (err) => fail(err));
+        }
+        else {
             res.pipe(fetchRes);
         }
     });
-
     setImmediate(() => {
         if (body) {
             try {
@@ -396,16 +330,15 @@ function nmfetch(url, options) {
                     return body.pipe(req);
                 }
                 req.write(body);
-            } catch (err) {
-                finished = true;
-                err.code = errors.EFETCH;
-                err.sourceUrl = url;
-                fetchRes.emit('error', err);
-                return;
+            }
+            catch (err) {
+                return fail(err);
             }
         }
         req.end();
     });
-
     return fetchRes;
 }
+nmfetch.Cookies = Cookies;
+nmfetch.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+export default nmfetch;

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

@@ -0,0 +1,64 @@
+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 JSON transport
+ */
+export interface JSONTransportOptions extends TransportOptions {
+    /** Selects this transport in createTransport */
+    jsonTransport?: boolean | undefined;
+    /** If true, the message is returned as an object instead of a JSON string */
+    skipEncoding?: boolean | undefined;
+}
+/**
+ * The value the JSON transport hands to the send callback. M is the type of the message
+ * field: a JSON string by default, the message object itself when skipEncoding is set
+ */
+export interface JSONSentMessageInfo<M = string> extends SentMessageInfo {
+    /** The envelope the message was generated with */
+    envelope: MimeNodeEnvelope;
+    /** Message-ID value of the message */
+    messageId: string;
+    /** The normalized message as a JSON string, or as the object itself when skipEncoding is set */
+    message: M;
+}
+/**
+ * The value the JSON transport hands to the send callback when skipEncoding is set: the
+ * message field holds the message object. Typed loosely so that a transporter created with
+ * skipEncoding still fits a variable declared with the plain result type
+ */
+export type JSONSentMessageObjectInfo = JSONSentMessageInfo<any>;
+/**
+ * Generates a Transport object to generate JSON output
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+declare class JSONTransport {
+    mailer: Mail<JSONSentMessageInfo>;
+    options: JSONTransportOptions;
+    name: string;
+    version: string;
+    logger: Logger;
+    constructor(options?: JSONTransportOptions);
+    /**
+     * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
+     *
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
+     */
+    send(mail: MailMessage<JSONSentMessageInfo>, done: (err: Error | null, info?: JSONSentMessageInfo) => void): void;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `JSONTransport.Options` style references keep working
+ */
+declare namespace JSONTransport {
+    type Options = JSONTransportOptions;
+    type MailOptions = SendMailOptions;
+    type SentMessageInfo = JSONSentMessageInfo;
+    type SentMessageObjectInfo = JSONSentMessageObjectInfo;
+}
+/** The same aliases as module level exports, for `import * as JSONTransport` and `import JSONTransport = require()` */
+export type { JSONTransportOptions as Options, SendMailOptions as MailOptions, JSONSentMessageInfo as SentMessageInfo, JSONSentMessageObjectInfo as SentMessageObjectInfo };
+export default JSONTransport;

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

@@ -1,74 +1,55 @@
-'use strict';
-
-const packageData = require('../../package.json');
-const shared = require('../shared');
-
+import * as packageData from '../package-info.js';
+import * as shared from '../shared/index.js';
 /**
  * Generates a Transport object to generate JSON output
  *
  * @constructor
- * @param {Object} optional config parameter
+ * @param optional config parameter
  */
 class JSONTransport {
     constructor(options) {
         options = options || {};
-
         this.options = options;
-
         this.name = 'JSONTransport';
         this.version = packageData.version;
-
         this.logger = shared.getLogger(this.options, {
             component: this.options.component || 'json-transport'
         });
     }
-
     /**
      * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
      *
-     * @param {Object} emailMessage MailComposer object
-     * @param {Function} callback Callback function to run when the sending is completed
+     * @param mail MailComposer object
+     * @param done Callback function to run when the sending is completed
      */
     send(mail, done) {
-        // Sendmail strips this header line by itself
+        // Sendmail strips this header line by itself. send() runs after the message was
+        // compiled, so mail.message is set
         mail.message.keepBcc = true;
-
         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
-            },
-            'Composing JSON structure of %s to <%s>',
-            messageId,
-            recipients.join(', ')
-        );
-
+        this.logger.info({
+            tnx: 'send',
+            messageId
+        }, 'Composing JSON structure of %s to <%s>', messageId, recipients.join(', '));
         setImmediate(() => {
             mail.normalize((err, data) => {
                 if (err) {
-                    this.logger.error(
-                        {
-                            err,
-                            tnx: 'send',
-                            messageId
-                        },
-                        'Failed building JSON structure for %s. %s',
-                        messageId,
-                        err.message
-                    );
+                    this.logger.error({
+                        err,
+                        tnx: 'send',
+                        messageId
+                    }, 'Failed building JSON structure for %s. %s', messageId, err.message);
                     return done(err);
                 }
-
                 delete data.envelope;
                 delete data.normalizedHeaders;
-
+                // the message field is the object itself with skipEncoding, the
+                // createTransport overload for that option types the result accordingly
                 return done(null, {
                     envelope,
                     messageId,
@@ -78,5 +59,4 @@ class JSONTransport {
         });
     }
 }
-
-module.exports = JSONTransport;
+export default JSONTransport;