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

package/dist/node_modules/nodemailer/dist/esm/ses-transport/index.js

@@ -0,0 +1,212 @@
+import EventEmitter from 'node:events';
+import * as packageData from '../package-info.js';
+import * as shared from '../shared/index.js';
+import * as errors from '../errors.js';
+import LeWindows from '../mime-node/le-windows.js';
+import MimeNode from '../mime-node/index.js';
+/**
+ * Tags AWS SDK rejections that carry no `code` property (SDK v3 errors only
+ * have a `name`) with the generic SES transport error code, keeping the
+ * original error object intact
+ */
+function tagSesError(err) {
+    if (err && typeof err === 'object' && !err.code) {
+        err.code = errors.ESES;
+    }
+    return err;
+}
+/**
+ * Generates a Transport object for AWS SES
+ *
+ * @constructor
+ * @param optional config parameter
+ */
+class SESTransport extends EventEmitter {
+    constructor(options) {
+        super();
+        if (!options || !options.SES || !options.SES.sesClient) {
+            const error = new Error('Missing SES configuration, expecting { sesClient, SendEmailCommand } from @aws-sdk/client-sesv2, see https://nodemailer.com/transports/ses/');
+            error.code = errors.ECONFIG;
+            throw error;
+        }
+        this.options = options;
+        this.ses = this.options.SES;
+        this.name = 'SESTransport';
+        this.version = packageData.version;
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'ses-transport'
+        });
+    }
+    getRegion(cb) {
+        if (this.ses.sesClient.config && typeof this.ses.sesClient.config.region === 'function') {
+            // Resolve the region provider. Use the two-argument form of then() so that a
+            // synchronous throw from cb is not recaught here and used to invoke cb a second time.
+            this.ses.sesClient.config.region().then(region => cb(null, region), err => cb(err));
+            return;
+        }
+        return cb(null, false);
+    }
+    /**
+     * Compiles a mailcomposer message and forwards it to SES
+     *
+     * @param mail MailComposer object
+     * @param callback Callback function to run when the sending is completed
+     */
+    send(mail, callback) {
+        // send() runs after the message was compiled, so mail.message is set
+        let fromHeader = mail.message._headers.find(header => /^from$/i.test(header.key));
+        if (fromHeader) {
+            const mimeNode = new MimeNode('text/plain');
+            fromHeader = mimeNode._convertAddresses(mimeNode._parseAddresses(fromHeader.value));
+        }
+        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
+        }, 'Sending message %s to <%s>', messageId, recipients.join(', '));
+        const getRawMessage = (next) => {
+            // do not use Message-ID and Date in DKIM signature
+            if (!mail.data._dkim) {
+                mail.data._dkim = {};
+            }
+            if (mail.data._dkim.skipFields && typeof mail.data._dkim.skipFields === 'string') {
+                mail.data._dkim.skipFields += ':date:message-id';
+            }
+            else {
+                mail.data._dkim.skipFields = 'date:message-id';
+            }
+            const sourceStream = mail.message.createReadStream();
+            const stream = sourceStream.pipe(new LeWindows());
+            const chunks = [];
+            let chunklen = 0;
+            stream.on('readable', () => {
+                let chunk;
+                while ((chunk = stream.read()) !== null) {
+                    chunks.push(chunk);
+                    chunklen += chunk.length;
+                }
+            });
+            sourceStream.once('error', err => stream.emit('error', err));
+            stream.once('error', err => next(err));
+            stream.once('end', () => next(null, Buffer.concat(chunks, chunklen)));
+        };
+        setImmediate(() => getRawMessage((err, raw) => {
+            if (err) {
+                this.logger.error({
+                    err,
+                    tnx: 'send',
+                    messageId
+                }, 'Failed creating message for %s. %s', messageId, err.message);
+                return callback(err);
+            }
+            // mail.data.ses is caller supplied message data, so copy its own keys only
+            const sesMessage = shared.copyOwnKeys({
+                Content: {
+                    Raw: {
+                        // required
+                        Data: raw // required
+                    }
+                },
+                FromEmailAddress: fromHeader || envelope.from,
+                Destination: {
+                    ToAddresses: envelope.to
+                }
+            }, mail.data.ses);
+            this.getRegion((err, region) => {
+                if (err || !region) {
+                    region = 'us-east-1';
+                }
+                let sendPromise;
+                try {
+                    // command construction or dispatch can throw synchronously on a
+                    // misconfigured SDK; surface it as a single error callback instead
+                    // of letting it escape into getRegion's promise chain
+                    const command = new this.ses.SendEmailCommand(sesMessage);
+                    sendPromise = this.ses.sesClient.send(command);
+                }
+                catch (err) {
+                    tagSesError(err);
+                    this.logger.error({
+                        err,
+                        tnx: 'send'
+                    }, 'Send error for %s: %s', messageId, err.message);
+                    setImmediate(() => callback(err));
+                    return;
+                }
+                sendPromise
+                    .then(data => {
+                    if (region === 'us-east-1') {
+                        region = 'email';
+                    }
+                    const info = {
+                        envelope: {
+                            from: envelope.from,
+                            to: envelope.to
+                        },
+                        messageId: '<' + data.MessageId + (!/@/.test(data.MessageId) ? '@' + region + '.amazonses.com' : '') + '>',
+                        response: data.MessageId,
+                        raw: raw
+                    };
+                    // invoke the callback outside the promise chain so a throw from it
+                    // is not recaught by .catch() and used to call it a second time
+                    setImmediate(() => callback(null, info));
+                })
+                    .catch(err => {
+                    tagSesError(err);
+                    this.logger.error({
+                        err,
+                        tnx: 'send'
+                    }, 'Send error for %s: %s', messageId, err.message);
+                    setImmediate(() => callback(err));
+                });
+            });
+        }));
+    }
+    verify(callback) {
+        let promise;
+        if (!callback) {
+            promise = new Promise((resolve, reject) => {
+                callback = shared.callbackPromise(resolve, reject);
+            });
+        }
+        const done = callback;
+        const cb = (err) => {
+            if (err && !['InvalidParameterValue', 'MessageRejected'].includes(err.code || err.Code || err.name)) {
+                return done(tagSesError(err));
+            }
+            return done(null, true);
+        };
+        const sesMessage = {
+            Content: {
+                Raw: {
+                    Data: Buffer.from('From: <invalid@invalid>\r\nTo: <invalid@invalid>\r\n Subject: Invalid\r\n\r\nInvalid')
+                }
+            },
+            FromEmailAddress: 'invalid@invalid',
+            Destination: {
+                ToAddresses: ['invalid@invalid']
+            }
+        };
+        // the region value is not used for anything when verifying, but the lookup
+        // exercises the client configuration the same way as send() does
+        this.getRegion(() => {
+            let sendPromise;
+            try {
+                const command = new this.ses.SendEmailCommand(sesMessage);
+                sendPromise = this.ses.sesClient.send(command);
+            }
+            catch (err) {
+                setImmediate(() => cb(err));
+                return;
+            }
+            sendPromise.then(() => setImmediate(() => cb(null))).catch(err => setImmediate(() => cb(err)));
+        });
+        return promise;
+    }
+}
+export default SESTransport;

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

@@ -0,0 +1,260 @@
+import { isProtoKey, copyOwnKeys } from './objects.js';
+import os from 'node:os';
+import type { Readable } from 'node:stream';
+import type { OutgoingHttpHeaders } from 'node:http';
+export { isProtoKey, copyOwnKeys };
+/**
+ * Options for resolveHostname. The object is also handed to dns.Resolver, so its
+ * `timeout` and `tries` settings apply to the lookups
+ */
+export interface ResolveHostnameOptions {
+    /** Hostname or IP address to resolve */
+    host?: string | undefined;
+    /** Server name for TLS, used as the host when no host is set */
+    servername?: string | undefined;
+    /** Count loopback interfaces when checking which address families are usable */
+    allowInternalNetworkInterfaces?: boolean | undefined;
+    /** How long a resolved value stays cached, in milliseconds (default 5 minutes) */
+    dnsTtl?: number | undefined;
+    /** Query timeout in milliseconds, passed to dns.Resolver */
+    timeout?: number | undefined;
+    /** Number of query attempts, passed to dns.Resolver */
+    tries?: number | undefined;
+}
+/**
+ * Resolved value handed to the resolveHostname callback
+ */
+export interface ResolvedHostname {
+    /** Server name to use for TLS, false when an IP literal was given without one */
+    servername?: string | false | undefined;
+    /** Address to connect to, picked at random from the resolved addresses */
+    host?: string | null | undefined;
+    /** Whether the value came from the DNS cache */
+    cached?: boolean | undefined;
+    /** The resolver error when a cached value was used because of it */
+    error?: Error | undefined;
+}
+/** The name @types/nodemailer used for ResolvedHostname */
+export type ResolveHostnameValue = ResolvedHostname;
+/**
+ * Resolved addresses as stored in the DNS cache
+ */
+export interface DnsCacheValue {
+    addresses: string[];
+}
+/**
+ * A DNS cache entry
+ */
+export interface DnsCacheEntry {
+    value: DnsCacheValue;
+    /** Expiration time as a timestamp, entries without one never expire */
+    expires?: number | undefined;
+}
+/**
+ * Configuration object parsed from a connection url. Query parameters become
+ * top level keys, `tls.*` parameters go into `tls`
+ */
+export interface ConnectionUrlOptions {
+    secure?: boolean | undefined;
+    direct?: boolean | undefined;
+    port?: number | undefined;
+    host?: string | undefined;
+    /** Well-known service name from the ?service= query parameter */
+    service?: string | undefined;
+    auth?: {
+        user: string;
+        pass: string;
+    } | undefined;
+    tls?: {
+        [key: string]: unknown;
+    } | undefined;
+    [key: string]: unknown;
+}
+/**
+ * Structured data attached to a log line. tnx, sid and cid drive the line prefix
+ * of the default console logger
+ */
+export interface LogEntry {
+    /** 'server' or 'client' for SMTP transaction lines */
+    tnx?: string | undefined;
+    /** Session id */
+    sid?: string | undefined;
+    /** Connection id */
+    cid?: string | number | undefined;
+    level?: string | undefined;
+    [key: string]: any;
+}
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/** The name @types/nodemailer used for LogLevel */
+export type LoggerLevel = LogLevel;
+/**
+ * A logger supplied by the caller, bunyan style. Any object works, a level it does not
+ * implement is routed to one it does, see _logFunc
+ */
+export interface ExternalLogger {
+    trace?(...args: any[]): any;
+    debug?(...args: any[]): any;
+    info?(...args: any[]): any;
+    warn?(...args: any[]): any;
+    error?(...args: any[]): any;
+    fatal?(...args: any[]): any;
+    log?(...args: any[]): any;
+    [level: string]: any;
+}
+/**
+ * Options for getLogger
+ */
+export interface GetLoggerOptions {
+    /** A bunyan compatible logger, true for the default console logger, false or unset for no logging */
+    logger?: ExternalLogger | boolean | undefined;
+}
+/**
+ * A bunyan style log method: a data object followed by a printf style message, or the
+ * message alone
+ */
+export interface LogMethod {
+    (data: LogEntry | undefined, message?: string, ...args: any[]): void;
+    (message?: string, ...args: any[]): void;
+}
+/**
+ * The bunyan compatible logger interface returned by getLogger
+ */
+export interface Logger {
+    trace: LogMethod;
+    debug: LogMethod;
+    info: LogMethod;
+    warn: LogMethod;
+    error: LogMethod;
+    fatal: LogMethod;
+}
+/**
+ * A parsed data URI
+ */
+export interface ParsedDataURI {
+    /** Decoded payload */
+    data: Buffer;
+    /** 'base64', 'utf8' or 'utf-8' when the URI declared one, null otherwise */
+    encoding: string | null;
+    contentType: string;
+    /** Further `key=value` parameters from the metadata section */
+    params: {
+        [key: string]: string;
+    };
+}
+/**
+ * Access policy for resolveContent
+ */
+export interface ResolveContentOptions {
+    /** Reject content that points to a file path */
+    disableFileAccess?: boolean | undefined;
+    /** Reject content that points to a URL */
+    disableUrlAccess?: boolean | undefined;
+}
+/**
+ * An object value resolveContent understands. A plain string or Buffer value is returned as
+ * is and a readable stream is read into a Buffer, an object carries the content in `content`
+ * or points to it with `path` or `href`
+ */
+export interface ContentDescriptor {
+    /** The content itself, a string, a Buffer or a readable stream */
+    content?: string | Buffer | Readable | undefined;
+    /** Encoding of a string `content`, it is decoded into a Buffer unless it is utf8 or ascii */
+    encoding?: string | undefined;
+    /** File path, http(s) URL or data URI to read the content from */
+    path?: string | undefined;
+    /** URL to fetch the content from */
+    href?: string | undefined;
+    /** Request headers for a URL fetch */
+    httpHeaders?: OutgoingHttpHeaders | undefined;
+    /** TLS settings for a URL fetch, see nmfetch */
+    tls?: {
+        [key: string]: any;
+    } | undefined;
+}
+export type ResolveContentCallback = (err: Error | null, value?: any) => void;
+export declare let networkInterfaces: NodeJS.Dict<os.NetworkInterfaceInfo[]> | undefined;
+export declare const dnsCache: Map<string, DnsCacheEntry>;
+export declare const resolveHostname: (options: ResolveHostnameOptions | undefined, callback: (err: Error | null, result?: ResolvedHostname) => void) => void;
+/**
+ * Parses connection url to a structured configuration object
+ *
+ * @param str Connection url
+ * @return Configuration object
+ */
+export declare const parseConnectionUrl: (str?: string | null) => ConnectionUrlOptions;
+/**
+ * Returns a bunyan-compatible logger interface. Uses either provided logger or
+ * creates a default console logger
+ *
+ * @param [options] Options object that might include 'logger' value
+ * @param [defaults] Fields merged into every log entry, overridden by the fields of the entry itself
+ * @return bunyan compatible logger
+ */
+export declare const getLogger: (options?: GetLoggerOptions, defaults?: LogEntry) => Logger;
+/**
+ * Wrapper for creating a callback that either resolves or rejects a promise
+ * based on input
+ *
+ * @param resolve Function to run if callback is called
+ * @param reject Function to run if callback ends with an error
+ */
+export declare const callbackPromise: (resolve: (...args: any[]) => void, reject: (reason?: any) => void) => (...args: any[]) => void;
+export declare const parseDataURI: (uri: unknown) => ParsedDataURI | null;
+/**
+ * Resolves a String or a Buffer value for content value. Useful if the value
+ * is a Stream or a file or an URL. If the value is a Stream, overwrites
+ * the stream object with the resolved value (you can't stream a value twice).
+ *
+ * This is useful when you want to create a plugin that needs a content value,
+ * for example the `html` or `text` value as a String or a Buffer but not as
+ * a file path or an URL.
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param callback Callback function with (err, value)
+ */
+export declare function resolveContent(data: {
+    [key: string]: any;
+}, key: string | number, callback: ResolveContentCallback): void;
+/**
+ * Resolves a String or a Buffer value for content value
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param options Access policy: { disableFileAccess, disableUrlAccess }
+ * @param callback Callback function with (err, value)
+ */
+export declare function resolveContent(data: {
+    [key: string]: any;
+}, key: string | number, options: ResolveContentOptions | false | undefined, callback: ResolveContentCallback): void;
+/**
+ * Resolves a String or a Buffer value for content value
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param [options] Optional access policy: { disableFileAccess, disableUrlAccess }
+ * @returns Promise that resolves with the value
+ */
+export declare function resolveContent(data: {
+    [key: string]: any;
+}, key: string | number, options?: ResolveContentOptions | false): Promise<any>;
+/**
+ * Resolves a String or a Buffer value for content value
+ *
+ * @param data An object or an Array you want to resolve an element for, see ContentDescriptor for the values it understands
+ * @param key Property name or an Array index
+ * @param options Access policy: { disableFileAccess, disableUrlAccess }
+ * @param callback Callback function with (err, value), a Promise is returned if not set
+ */
+export declare function resolveContent(data: {
+    [key: string]: any;
+}, key: string | number, options: ResolveContentOptions | false | undefined, callback: ResolveContentCallback | undefined): Promise<any> | void;
+/**
+ * Copies properties from source objects to target objects
+ */
+export declare const assign: (...args: ({
+    [key: string]: any;
+} | false | null | undefined)[]) => {
+    [key: string]: any;
+};
+export declare const encodeXText: (str: string) => string;