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

package/dist/node_modules/nodemailer/dist/cjs/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/dist/cjs/base64/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encoder = void 0;
+exports.encode = encode;
+exports.wrap = wrap;
+const node_stream_1 = require("node:stream");
+/**
+ * Encodes a Buffer into a base64 encoded string
+ *
+ * @param buffer Buffer to convert
+ * @returns base64 encoded string
+ */
+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 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) {
+    str = (str || '').toString();
+    // 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;
+    }
+    const result = [];
+    let pos = 0;
+    const chunkLength = lineLength * 1024;
+    const wrapRegex = new RegExp('.{' + lineLength + '}', 'g');
+    while (pos < str.length) {
+        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 options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ */
+class Encoder extends node_stream_1.Transform {
+    constructor(options) {
+        super();
+        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) {
+        let buf = encoding !== 'buffer' ? Buffer.from(chunk, encoding) : chunk;
+        if (!buf || !buf.length) {
+            setImmediate(done);
+            return;
+        }
+        this.inputBytes += buf.length;
+        if (this._remainingBytes && this._remainingBytes.length) {
+            buf = Buffer.concat([this._remainingBytes, buf], this._remainingBytes.length + buf.length);
+            this._remainingBytes = false;
+        }
+        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(buf);
+        if (this.options.lineLength) {
+            b64 = wrap(b64, this.options.lineLength);
+            // remove last line as it is still most probably incomplete
+            const lastLF = b64.lastIndexOf('\n');
+            if (lastLF < 0) {
+                this._curLine = b64;
+                b64 = '';
+            }
+            else if (lastLF === b64.length - 1) {
+                this._curLine = '';
+            }
+            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(Buffer.from(this._curLine, 'ascii'));
+            this._curLine = '';
+        }
+        done();
+    }
+}
+exports.Encoder = Encoder;

package/dist/node_modules/nodemailer/dist/cjs/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/dist/cjs/dkim/index.js

@@ -0,0 +1,228 @@
+"use strict";
+// FIXME:
+// replace this Transform mess with a method that pipes input argument to output argument
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const message_parser_js_1 = __importDefault(require("./message-parser.js"));
+const relaxed_body_js_1 = __importDefault(require("./relaxed-body.js"));
+const sign_js_1 = __importDefault(require("./sign.js"));
+const node_stream_1 = require("node:stream");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const objects_js_1 = require("../shared/objects.js");
+const DKIM_ALGO = 'sha256';
+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
+            ? node_path_1.default.join(this.cacheDir, 'message.' + Date.now() + '-' + node_crypto_1.default.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;
+        }
+        node_fs_1.default.unlink(this.cachePath, () => false);
+    }
+    createReadCache() {
+        // pipe remainings to cache file
+        this.cache = node_fs_1.default.createReadStream(this.cachePath);
+        this.cache.once('error', err => {
+            this.cleanup();
+            this.output.emit('error', err);
+        });
+        this.cache.once('close', () => {
+            this.cleanup();
+        });
+        this.cache.pipe(this.output);
+    }
+    sendNextChunk() {
+        if (this.hasErrored) {
+            return;
+        }
+        if (this.readPos >= this.chunks.length) {
+            if (!this.cache) {
+                this.output.end();
+                return;
+            }
+            return this.createReadCache();
+        }
+        const chunk = this.chunks[this.readPos++];
+        if (this.output.write(chunk) === false) {
+            this.output.once('drain', () => {
+                this.sendNextChunk();
+            });
+            return;
+        }
+        setImmediate(() => this.sendNextChunk());
+    }
+    sendSignedOutput() {
+        let keyPos = 0;
+        const signNextKey = () => {
+            if (keyPos >= this.keys.length) {
+                this.output.write(this.parser.rawHeaders);
+                setImmediate(() => this.sendNextChunk());
+                return;
+            }
+            const key = this.keys[keyPos++];
+            let dkimField;
+            try {
+                dkimField = (0, sign_js_1.default)(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;
+            }
+            if (dkimField) {
+                this.output.write(Buffer.from(dkimField + '\r\n'));
+            }
+            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
+        this.cache = node_fs_1.default.createWriteStream(this.cachePath);
+        this.cache.once('error', err => {
+            this.cleanup();
+            // drain input
+            this.relaxedBody.unpipe(this.cache);
+            this.relaxedBody.on('readable', () => {
+                while (this.relaxedBody.read() !== null) {
+                    // do nothing
+                }
+            });
+            this.hasErrored = true;
+            // emit error
+            this.output.emit('error', err);
+        });
+        this.cache.once('close', () => {
+            this.sendSignedOutput();
+        });
+        this.relaxedBody.removeAllListeners('readable');
+        this.relaxedBody.pipe(this.cache);
+    }
+    signStream() {
+        this.parser = new message_parser_js_1.default();
+        this.relaxedBody = new relaxed_body_js_1.default({
+            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) {
+                return;
+            }
+            while ((chunk = this.relaxedBody.read()) !== null) {
+                this.chunks.push(chunk);
+                this.chunklen += chunk.length;
+                if (this.chunklen >= this.cacheTreshold && this.cachePath) {
+                    return this.createWriteCache();
+                }
+            }
+        });
+        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
+        });
+    }
+    sign(input, extraOptions) {
+        const output = new node_stream_1.PassThrough();
+        let inputStream = input;
+        let writeValue = false;
+        if (Buffer.isBuffer(input)) {
+            writeValue = input;
+            inputStream = new node_stream_1.PassThrough();
+        }
+        else if (typeof input === 'string') {
+            writeValue = Buffer.from(input);
+            inputStream = new node_stream_1.PassThrough();
+        }
+        let options = this.options;
+        if (extraOptions && Object.keys(extraOptions).length) {
+            // 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 = (0, objects_js_1.copyOwnKeys)({}, extraOptions);
+            (0, objects_js_1.copyOwnKeys)(options, this.options);
+        }
+        const signer = new DKIMSigner(options, this.keys, inputStream, output);
+        setImmediate(() => {
+            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_js_1.default.unsupportedHashAlgoError(signer.hashAlgo));
+                return;
+            }
+            if (writeValue) {
+                setImmediate(() => {
+                    inputStream.end(writeValue);
+                });
+            }
+        });
+        return output;
+    }
+}
+exports.default = DKIM;
+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/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;

package/dist/node_modules/nodemailer/dist/cjs/dkim/message-parser.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+/**
+ * Drops the SP and HTAB from both ends of a field name.
+ *
+ * An index scan rather than `/^[ \t]+|[ \t]+$/g`, which retries the trailing branch at
+ * every offset of a blank run that is followed by other text: the run is consumed greedily,
+ * `$` fails, and the engine gives the characters back one at a time before moving on to
+ * start the same walk one offset further in. A field name carrying a 128 KiB run of spaces
+ * between two atoms took about 6.7 seconds to trim, and the cost grows with its square.
+ *
+ * Not `.trim()`, which takes the other Unicode spaces along: an NBSP in front of a field
+ * name would come off and select the name into the signed set, where the relaxed
+ * canonicalization in sign.ts deliberately leaves everything but SP and HTAB alone.
+ *
+ * @param str Field name to trim
+ * @return The field name without the surrounding SP and HTAB
+ */
+function _trimFieldName(str) {
+    let start = 0;
+    let end = str.length;
+    while (start < end && (str.charCodeAt(start) === 0x20 || str.charCodeAt(start) === 0x09)) {
+        start++;
+    }
+    while (end > start && (str.charCodeAt(end - 1) === 0x20 || str.charCodeAt(end - 1) === 0x09)) {
+        end--;
+    }
+    return str.slice(start, end);
+}
+/**
+ * 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.
+ */
+class MessageParser extends node_stream_1.Transform {
+    constructor(options) {
+        super(options);
+        this.lastBytes = Buffer.alloc(4);
+        this.headersParsed = false;
+        this.headerBytes = 0;
+        this.headerChunks = [];
+        this.rawHeaders = false;
+        this.bodySize = 0;
+    }
+    /**
+     * 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) {
+        const lblen = this.lastBytes.length;
+        const nblen = Math.min(data.length, lblen);
+        // shift existing bytes
+        for (let i = 0, len = lblen - nblen; i < len; i++) {
+            this.lastBytes[i] = this.lastBytes[i + nblen];
+        }
+        // add new bytes
+        for (let i = 1; i <= nblen; i++) {
+            this.lastBytes[lblen - i] = data[data.length - i];
+        }
+    }
+    /**
+     * 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) {
+        if (this.headersParsed) {
+            return true;
+        }
+        const lblen = this.lastBytes.length;
+        let headerPos = 0;
+        for (let i = 0, len = this.lastBytes.length + data.length; i < len; i++) {
+            let chr;
+            if (i < lblen) {
+                chr = this.lastBytes[i];
+            }
+            else {
+                chr = data[i - lblen];
+            }
+            if (chr === 0x0a && i) {
+                const pr1 = i - 1 < lblen ? this.lastBytes[i - 1] : data[i - 1 - lblen];
+                const pr2 = i > 1 ? (i - 2 < lblen ? this.lastBytes[i - 2] : data[i - 2 - lblen]) : false;
+                if (pr1 === 0x0a) {
+                    this.headersParsed = true;
+                    headerPos = i - lblen + 1;
+                    this.headerBytes += headerPos;
+                    break;
+                }
+                else if (pr1 === 0x0d && pr2 === 0x0a) {
+                    this.headersParsed = true;
+                    headerPos = i - lblen + 1;
+                    this.headerBytes += headerPos;
+                    break;
+                }
+            }
+        }
+        if (this.headersParsed) {
+            this.headerChunks.push(data.slice(0, headerPos));
+            this.rawHeaders = Buffer.concat(this.headerChunks, this.headerBytes);
+            this.headerChunks = null;
+            this.emit('headers', this.parseHeaders());
+            if (data.length > headerPos) {
+                const chunk = data.slice(headerPos);
+                this.bodySize += chunk.length;
+                // this would be the first chunk of data sent downstream
+                setImmediate(() => this.push(chunk));
+            }
+            return false;
+        }
+        this.headerBytes += data.length;
+        this.headerChunks.push(data);
+        // store last 4 bytes to catch header break
+        this.updateLastBytes(data);
+        return false;
+    }
+    /** @internal */
+    _transform(chunk, encoding, callback) {
+        if (!chunk || !chunk.length) {
+            return callback();
+        }
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, encoding);
+        }
+        let headersFound;
+        try {
+            headersFound = this.checkHeaders(chunk);
+        }
+        catch (E) {
+            return callback(E);
+        }
+        if (headersFound) {
+            this.bodySize += chunk.length;
+            this.push(chunk);
+        }
+        setImmediate(callback);
+    }
+    /** @internal */
+    _flush(callback) {
+        if (this.headerChunks) {
+            // no empty line was seen, so the message consists of headers only
+            this.rawHeaders = Buffer.concat(this.headerChunks, this.headerBytes);
+            this.headerChunks = null;
+            this.emit('headers', this.parseHeaders());
+        }
+        callback();
+    }
+    parseHeaders() {
+        // the header bytes are kept as they are, one character per byte, so the
+        // signature covers exactly the bytes the receiving side canonicalizes
+        // Only SP and HTAB fold a line, and only they are trimmed from the field name, the
+        // same whitespace the relaxed canonicalization in sign.ts works with
+        const rawLines = (this.rawHeaders || Buffer.alloc(0)).toString('binary').split(/\r?\n/);
+        // Unfold in a single forward pass and only ever test a freshly split line for the
+        // continuation prefix. Testing an already merged line instead would rescan a string
+        // that grows with every continuation line, so a header folded into many continuation
+        // lines (a large recipient list, for example) would take quadratic time to unfold
+        const lines = [];
+        for (const rawLine of rawLines) {
+            if (lines.length && /^[ \t]/.test(rawLine)) {
+                lines[lines.length - 1] += '\n' + rawLine;
+            }
+            else {
+                lines.push(rawLine);
+            }
+        }
+        return lines
+            .filter(line => /[^ \t\r]/.test(line))
+            .map(line => ({
+            key: _trimFieldName(line.substr(0, line.indexOf(':'))).toLowerCase(),
+            line
+        }));
+    }
+}
+exports.default = MessageParser;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });