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

package/dist/node_modules/nodemailer/dist/esm/base64/index.d.ts

@@ -0,0 +1,36 @@
+import { Transform } from 'node:stream';
+/**
+ * Encodes a Buffer into a base64 encoded string
+ *
+ * @param buffer Buffer to convert
+ * @returns base64 encoded string
+ */
+export declare function encode(buffer: Buffer | string): string;
+/**
+ * Adds soft line breaks to a base64 string
+ *
+ * @param str base64 encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped base64 encoded string
+ */
+export declare function wrap(str: string, lineLength?: number | false): string;
+/**
+ * Options for the base64 encoder stream
+ */
+export interface EncoderOptions {
+    /** Maximum length for lines, set to false to disable wrapping */
+    lineLength?: number | false | undefined;
+}
+/**
+ * Creates a transform stream for encoding data to base64 encoding
+ *
+ * @constructor
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ */
+export declare class Encoder extends Transform {
+    options: EncoderOptions;
+    inputBytes: number;
+    outputBytes: number;
+    constructor(options?: EncoderOptions);
+}

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

@@ -1,142 +1,113 @@
-'use strict';
-
-const Transform = require('stream').Transform;
-
+import { Transform } from 'node:stream';
 /**
  * Encodes a Buffer into a base64 encoded string
  *
- * @param {Buffer} buffer Buffer to convert
- * @returns {String} base64 encoded string
+ * @param buffer Buffer to convert
+ * @returns base64 encoded string
  */
-function encode(buffer) {
+export function encode(buffer) {
     if (typeof buffer === 'string') {
         buffer = Buffer.from(buffer, 'utf-8');
     }
-
     return buffer.toString('base64');
 }
-
 /**
  * Adds soft line breaks to a base64 string
  *
- * @param {String} str base64 encoded string that might need line wrapping
- * @param {Number} [lineLength=76] Maximum allowed length for a line
- * @returns {String} Soft-wrapped base64 encoded string
+ * @param str base64 encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped base64 encoded string
  */
-function wrap(str, lineLength) {
+export function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = lineLength || 76;
-
+    // a negative length would step backwards through the input and never finish
+    lineLength = Math.max(Number(lineLength) || 76, 1);
     if (str.length <= lineLength) {
         return str;
     }
-
-    let result = [];
+    const result = [];
     let pos = 0;
-    let chunkLength = lineLength * 1024;
+    const chunkLength = lineLength * 1024;
+    const wrapRegex = new RegExp('.{' + lineLength + '}', 'g');
     while (pos < str.length) {
-        let wrappedLines = str
-            .substr(pos, chunkLength)
-            .replace(new RegExp('.{' + lineLength + '}', 'g'), '$&\r\n')
-            .trim();
+        const wrappedLines = str.substr(pos, chunkLength).replace(wrapRegex, '$&\r\n').trim();
         result.push(wrappedLines);
         pos += chunkLength;
     }
-
     return result.join('\r\n').trim();
 }
-
 /**
  * Creates a transform stream for encoding data to base64 encoding
  *
  * @constructor
- * @param {Object} options Stream options
- * @param {Number} [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
  */
-class Encoder extends Transform {
+export class Encoder extends Transform {
     constructor(options) {
         super();
-        // init Transform
         this.options = options || {};
-
         if (this.options.lineLength !== false) {
             this.options.lineLength = this.options.lineLength || 76;
         }
-
         this._curLine = '';
         this._remainingBytes = false;
-
         this.inputBytes = 0;
         this.outputBytes = 0;
     }
-
+    /** @internal */
     _transform(chunk, encoding, done) {
-        if (encoding !== 'buffer') {
-            chunk = Buffer.from(chunk, encoding);
+        let buf = encoding !== 'buffer' ? Buffer.from(chunk, encoding) : chunk;
+        if (!buf || !buf.length) {
+            setImmediate(done);
+            return;
         }
-
-        if (!chunk || !chunk.length) {
-            return setImmediate(done);
-        }
-
-        this.inputBytes += chunk.length;
-
+        this.inputBytes += buf.length;
         if (this._remainingBytes && this._remainingBytes.length) {
-            chunk = Buffer.concat([this._remainingBytes, chunk], this._remainingBytes.length + chunk.length);
+            buf = Buffer.concat([this._remainingBytes, buf], this._remainingBytes.length + buf.length);
             this._remainingBytes = false;
         }
-
-        if (chunk.length % 3) {
-            this._remainingBytes = chunk.slice(chunk.length - (chunk.length % 3));
-            chunk = chunk.slice(0, chunk.length - (chunk.length % 3));
-        } else {
+        if (buf.length % 3) {
+            this._remainingBytes = buf.slice(buf.length - (buf.length % 3));
+            buf = buf.slice(0, buf.length - (buf.length % 3));
+        }
+        else {
             this._remainingBytes = false;
         }
-
-        let b64 = this._curLine + encode(chunk);
-
+        let b64 = this._curLine + encode(buf);
         if (this.options.lineLength) {
             b64 = wrap(b64, this.options.lineLength);
-
             // remove last line as it is still most probably incomplete
-            let lastLF = b64.lastIndexOf('\n');
+            const lastLF = b64.lastIndexOf('\n');
             if (lastLF < 0) {
                 this._curLine = b64;
                 b64 = '';
-            } else if (lastLF === b64.length - 1) {
+            }
+            else if (lastLF === b64.length - 1) {
                 this._curLine = '';
-            } else {
-                this._curLine = b64.substr(lastLF + 1);
-                b64 = b64.substr(0, lastLF + 1);
+            }
+            else {
+                this._curLine = b64.substring(lastLF + 1);
+                b64 = b64.substring(0, lastLF + 1);
             }
         }
-
         if (b64) {
             this.outputBytes += b64.length;
             this.push(Buffer.from(b64, 'ascii'));
         }
-
         setImmediate(done);
     }
-
+    /** @internal */
     _flush(done) {
         if (this._remainingBytes && this._remainingBytes.length) {
             this._curLine += encode(this._remainingBytes);
         }
-
         if (this._curLine) {
             this._curLine = wrap(this._curLine, this.options.lineLength);
             this.outputBytes += this._curLine.length;
-            this.push(this._curLine, 'ascii');
+            this.push(Buffer.from(this._curLine, 'ascii'));
             this._curLine = '';
         }
         done();
     }
 }
-
-// expose to the world
-module.exports = {
-    encode,
-    wrap,
-    Encoder
-};

package/dist/node_modules/nodemailer/dist/esm/dkim/index.d.ts

@@ -0,0 +1,52 @@
+import { type DKIMKey, type DKIMPrivateKey, type DKIMSignOptions } from './sign.js';
+import { PassThrough, type Readable } from 'node:stream';
+/**
+ * A single DKIM signing key
+ */
+export type { DKIMKey, DKIMPrivateKey, DKIMSignOptions };
+/**
+ * Options for the DKIM signer
+ */
+export interface DKIMOptions extends DKIMSignOptions {
+    /** One or more signing keys, used instead of the domainName, keySelector and privateKey options */
+    keys?: DKIMKey | DKIMKey[] | undefined;
+    /** Directory for buffering large message bodies to disk, no buffering when not set */
+    cacheDir?: string | false | undefined;
+    /** Body size in bytes from which the body is buffered to cacheDir, defaults to 10 MB */
+    cacheTreshold?: number | undefined;
+    /** Hash algorithm for the body hash and the signature, defaults to sha256 */
+    hashAlgo?: string | undefined;
+}
+/**
+ * The signed message as returned by DKIM#sign
+ */
+export interface DKIMSignedStream extends PassThrough {
+    /** true if the message body was buffered to cacheDir while signing */
+    usingCache: boolean;
+}
+declare class DKIM {
+    options: DKIMOptions;
+    keys: DKIMKey[];
+    constructor(options: DKIMOptions);
+    sign(input: Readable | Buffer | string, extraOptions?: DKIMOptions): DKIMSignedStream;
+}
+/** The signer options without any key material */
+export type DKIMOptionalOptions = Omit<DKIMOptions, 'keys' | 'domainName' | 'keySelector' | 'privateKey'>;
+/** The signer options for a single key given as domainName, keySelector and privateKey */
+export type DKIMSingleKeyOptions = Omit<DKIMOptions, 'keys'>;
+/** The signer options for one or more keys given through `keys` */
+export type DKIMMultipleKeysOptions = DKIMOptionalOptions & {
+    keys: DKIMKey | DKIMKey[];
+};
+/**
+ * Type aliases in the layout of @types/nodemailer, so `DKIM.Options` style references keep working
+ */
+declare namespace DKIM {
+    type Options = DKIMOptions;
+    type OptionalOptions = DKIMOptionalOptions;
+    type SingleKeyOptions = DKIMSingleKeyOptions;
+    type MultipleKeysOptions = DKIMMultipleKeysOptions;
+}
+/** The same aliases as module level exports, for `import * as DKIM` and `import DKIM = require()` */
+export type { DKIMOptions as Options, DKIMOptionalOptions as OptionalOptions, DKIMSingleKeyOptions as SingleKeyOptions, DKIMMultipleKeysOptions as MultipleKeysOptions };
+export default DKIM;

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

@@ -1,75 +1,49 @@
-'use strict';
-
 // FIXME:
 // replace this Transform mess with a method that pipes input argument to output argument
-
-const MessageParser = require('./message-parser');
-const RelaxedBody = require('./relaxed-body');
-const sign = require('./sign');
-const PassThrough = require('stream').PassThrough;
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
+import MessageParser from './message-parser.js';
+import RelaxedBody from './relaxed-body.js';
+import sign from './sign.js';
+import { PassThrough } from 'node:stream';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { copyOwnKeys } from '../shared/objects.js';
 const DKIM_ALGO = 'sha256';
-const MAX_MESSAGE_SIZE = 128 * 1024; // buffer messages larger than this to disk
-
-/*
-// Usage:
-
-let dkim = new DKIM({
-    domainName: 'example.com',
-    keySelector: 'key-selector',
-    privateKey,
-    cacheDir: '/tmp'
-});
-dkim.sign(input).pipe(process.stdout);
-
-// Where inputStream is a rfc822 message (either a stream, string or Buffer)
-// and outputStream is a DKIM signed rfc822 message
-*/
-
+const MAX_MESSAGE_SIZE = 10 * 1024 * 1024; // buffer messages larger than this to disk
 class DKIMSigner {
     constructor(options, keys, input, output) {
         this.options = options || {};
         this.keys = keys;
-
         this.cacheTreshold = Number(this.options.cacheTreshold) || MAX_MESSAGE_SIZE;
         this.hashAlgo = this.options.hashAlgo || DKIM_ALGO;
-
         this.cacheDir = this.options.cacheDir || false;
-
         this.chunks = [];
         this.chunklen = 0;
         this.readPos = 0;
-        this.cachePath = this.cacheDir ? path.join(this.cacheDir, 'message.' + Date.now() + '-' + crypto.randomBytes(14).toString('hex')) : false;
+        this.cachePath = this.cacheDir
+            ? path.join(this.cacheDir, 'message.' + Date.now() + '-' + crypto.randomBytes(14).toString('hex'))
+            : false;
         this.cache = false;
-
         this.headers = false;
         this.bodyHash = false;
         this.parser = false;
         this.relaxedBody = false;
-
         this.input = input;
         this.output = output;
         this.output.usingCache = false;
-
         this.hasErrored = false;
-
         this.input.on('error', err => {
             this.hasErrored = true;
             this.cleanup();
             output.emit('error', err);
         });
     }
-
     cleanup() {
         if (!this.cache || !this.cachePath) {
             return;
         }
         fs.unlink(this.cachePath, () => false);
     }
-
     createReadCache() {
         // pipe remainings to cache file
         this.cache = fs.createReadStream(this.cachePath);
@@ -82,56 +56,62 @@ class DKIMSigner {
         });
         this.cache.pipe(this.output);
     }
-
     sendNextChunk() {
         if (this.hasErrored) {
             return;
         }
-
         if (this.readPos >= this.chunks.length) {
             if (!this.cache) {
-                return this.output.end();
+                this.output.end();
+                return;
             }
             return this.createReadCache();
         }
-        let chunk = this.chunks[this.readPos++];
+        const chunk = this.chunks[this.readPos++];
         if (this.output.write(chunk) === false) {
-            return this.output.once('drain', () => {
+            this.output.once('drain', () => {
                 this.sendNextChunk();
             });
+            return;
         }
         setImmediate(() => this.sendNextChunk());
     }
-
     sendSignedOutput() {
         let keyPos = 0;
-        let signNextKey = () => {
+        const signNextKey = () => {
             if (keyPos >= this.keys.length) {
                 this.output.write(this.parser.rawHeaders);
-                return setImmediate(() => this.sendNextChunk());
+                setImmediate(() => this.sendNextChunk());
+                return;
+            }
+            const key = this.keys[keyPos++];
+            let dkimField;
+            try {
+                dkimField = sign(this.headers, this.hashAlgo, this.bodyHash, {
+                    domainName: key.domainName,
+                    keySelector: key.keySelector,
+                    privateKey: key.privateKey,
+                    headerFieldNames: this.options.headerFieldNames,
+                    skipFields: this.options.skipFields
+                });
+            }
+            catch (err) {
+                this.hasErrored = true;
+                this.cleanup();
+                this.output.emit('error', err);
+                return;
             }
-            let key = this.keys[keyPos++];
-            let dkimField = sign(this.headers, this.hashAlgo, this.bodyHash, {
-                domainName: key.domainName,
-                keySelector: key.keySelector,
-                privateKey: key.privateKey,
-                headerFieldNames: this.options.headerFieldNames,
-                skipFields: this.options.skipFields
-            });
             if (dkimField) {
                 this.output.write(Buffer.from(dkimField + '\r\n'));
             }
-            return setImmediate(signNextKey);
+            setImmediate(signNextKey);
         };
-
         if (this.bodyHash && this.headers) {
             return signNextKey();
         }
-
         this.output.write(this.parser.rawHeaders);
         this.sendNextChunk();
     }
-
     createWriteCache() {
         this.output.usingCache = true;
         // pipe remainings to cache file
@@ -155,21 +135,17 @@ class DKIMSigner {
         this.relaxedBody.removeAllListeners('readable');
         this.relaxedBody.pipe(this.cache);
     }
-
     signStream() {
         this.parser = new MessageParser();
         this.relaxedBody = new RelaxedBody({
             hashAlgo: this.hashAlgo
         });
-
         this.parser.on('headers', value => {
             this.headers = value;
         });
-
         this.relaxedBody.on('hash', value => {
             this.bodyHash = value;
         });
-
         this.relaxedBody.on('readable', () => {
             let chunk;
             if (this.cache) {
@@ -183,69 +159,63 @@ class DKIMSigner {
                 }
             }
         });
-
         this.relaxedBody.on('end', () => {
             if (this.cache) {
                 return;
             }
             this.sendSignedOutput();
         });
-
         this.parser.pipe(this.relaxedBody);
         setImmediate(() => this.input.pipe(this.parser));
     }
 }
-
 class DKIM {
     constructor(options) {
         this.options = options || {};
-        this.keys = [].concat(
-            this.options.keys || {
-                domainName: options.domainName,
-                keySelector: options.keySelector,
-                privateKey: options.privateKey
-            }
-        );
+        this.keys = [].concat(this.options.keys || {
+            domainName: options.domainName,
+            keySelector: options.keySelector,
+            privateKey: options.privateKey
+        });
     }
-
     sign(input, extraOptions) {
-        let output = new PassThrough();
+        const output = new PassThrough();
         let inputStream = input;
         let writeValue = false;
-
         if (Buffer.isBuffer(input)) {
             writeValue = input;
             inputStream = new PassThrough();
-        } else if (typeof input === 'string') {
+        }
+        else if (typeof input === 'string') {
             writeValue = Buffer.from(input);
             inputStream = new PassThrough();
         }
-
         let options = this.options;
         if (extraOptions && Object.keys(extraOptions).length) {
-            options = {};
-            Object.keys(this.options || {}).forEach(key => {
-                options[key] = this.options[key];
-            });
-            Object.keys(extraOptions || {}).forEach(key => {
-                if (!(key in options)) {
-                    options[key] = extraOptions[key];
-                }
-            });
+            // extraOptions is mail.data._dkim, caller supplied message data. An own
+            // "__proto__" key there would let every option this signer reads and the
+            // transport did not set, such as skipFields, answer from the caller
+            options = copyOwnKeys({}, extraOptions);
+            copyOwnKeys(options, this.options);
         }
-
-        let signer = new DKIMSigner(options, this.keys, inputStream, output);
+        const signer = new DKIMSigner(options, this.keys, inputStream, output);
         setImmediate(() => {
-            signer.signStream();
+            try {
+                signer.signStream();
+            }
+            catch (_E) {
+                // the body hash is created here, an unknown hashAlgo throws inside this timer
+                // where nothing else could catch it
+                output.emit('error', sign.unsupportedHashAlgoError(signer.hashAlgo));
+                return;
+            }
             if (writeValue) {
                 setImmediate(() => {
                     inputStream.end(writeValue);
                 });
             }
         });
-
         return output;
     }
 }
-
-module.exports = DKIM;
+export default DKIM;

package/dist/node_modules/nodemailer/dist/esm/dkim/message-parser.d.ts

@@ -0,0 +1,48 @@
+import { Transform, type TransformOptions } from 'node:stream';
+/**
+ * A header line as emitted with the 'headers' event
+ */
+export interface MessageParserHeaderLine {
+    /** Lowercase header field name */
+    key: string;
+    /** Full header line, folded continuation lines included, one character per byte ('binary' encoding) */
+    line: string;
+}
+/**
+ * MessageParser instance is a transform stream that separates message headers
+ * from the rest of the body. Headers are emitted with the 'headers' event. Message
+ * body is passed on as the resulting stream.
+ */
+declare class MessageParser extends Transform {
+    lastBytes: Buffer;
+    headersParsed: boolean;
+    headerBytes: number;
+    headerChunks: Buffer[] | null;
+    rawHeaders: Buffer | false;
+    bodySize: number;
+    constructor(options?: TransformOptions);
+    /**
+     * Keeps count of the last 4 bytes in order to detect line breaks on chunk boundaries
+     *
+     * @param data Next data chunk from the stream
+     */
+    updateLastBytes(data: Buffer): void;
+    /**
+     * Finds and removes message headers from the remaining body. We want to keep
+     * headers separated until final delivery to be able to modify these
+     *
+     * @param data Next chunk of data
+     * @return Returns true if headers are already found or false otherwise
+     */
+    checkHeaders(data: Buffer): boolean;
+    parseHeaders(): MessageParserHeaderLine[];
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `MessageParser.Header` style references keep working
+ */
+declare namespace MessageParser {
+    type Header = MessageParserHeaderLine;
+}
+/** The same alias as a module level export, for `import * as MessageParser` and `import MessageParser = require()` */
+export type { MessageParserHeaderLine as Header };
+export default MessageParser;