@nocobase/plugin-workflow-mailer 2.3.0-beta.9 → 2.4.0-alpha.10

package/dist/node_modules/nodemailer/dist/esm/errors.js

@@ -0,0 +1,67 @@
+/**
+ * Nodemailer Error Codes
+ *
+ * Centralized error code definitions for consistent error handling.
+ *
+ * Usage:
+ *   import * as errors from './errors.js';
+ *   const err: NodemailerError = new Error('Connection closed');
+ *   err.code = errors.ECONNECTION;
+ */
+/**
+ * Error code descriptions for documentation and debugging
+ */
+export const ERROR_CODES = {
+    // Connection errors
+    ECONNECTION: 'Connection closed unexpectedly',
+    ETIMEDOUT: 'Connection or operation timed out',
+    ESOCKET: 'Socket-level error',
+    EDNS: 'DNS resolution failed',
+    // TLS/Security errors
+    ETLS: 'TLS handshake or STARTTLS failed',
+    EREQUIRETLS: 'REQUIRETLS not supported by server (RFC 8689)',
+    // Protocol errors
+    EPROTOCOL: 'Invalid SMTP server response',
+    EENVELOPE: 'Invalid mail envelope (sender or recipients)',
+    EMESSAGE: 'Message delivery error',
+    ESTREAM: 'Stream processing error',
+    // Authentication errors
+    EAUTH: 'Authentication failed',
+    ENOAUTH: 'Authentication credentials not provided',
+    EOAUTH2: 'OAuth2 token generation or refresh error',
+    // Resource errors
+    EMAXLIMIT: 'Pool resource limit reached (max messages per connection)',
+    EMAXRECIPIENTS: 'Recipient count exceeds maxRecipients',
+    // Transport-specific errors
+    ESENDMAIL: 'Sendmail command error',
+    ESES: 'AWS SES transport error',
+    // Configuration and access errors
+    ECONFIG: 'Invalid configuration',
+    EPROXY: 'Proxy connection error',
+    EFILEACCESS: 'File access rejected (disableFileAccess is set)',
+    EURLACCESS: 'URL access rejected (disableUrlAccess is set)',
+    EFETCH: 'HTTP fetch error'
+};
+// Error codes as string constants
+export const ECONNECTION = 'ECONNECTION';
+export const ETIMEDOUT = 'ETIMEDOUT';
+export const ESOCKET = 'ESOCKET';
+export const EDNS = 'EDNS';
+export const ETLS = 'ETLS';
+export const EREQUIRETLS = 'EREQUIRETLS';
+export const EPROTOCOL = 'EPROTOCOL';
+export const EENVELOPE = 'EENVELOPE';
+export const EMESSAGE = 'EMESSAGE';
+export const ESTREAM = 'ESTREAM';
+export const EAUTH = 'EAUTH';
+export const ENOAUTH = 'ENOAUTH';
+export const EOAUTH2 = 'EOAUTH2';
+export const EMAXLIMIT = 'EMAXLIMIT';
+export const EMAXRECIPIENTS = 'EMAXRECIPIENTS';
+export const ESENDMAIL = 'ESENDMAIL';
+export const ESES = 'ESES';
+export const ECONFIG = 'ECONFIG';
+export const EPROXY = 'EPROXY';
+export const EFILEACCESS = 'EFILEACCESS';
+export const EURLACCESS = 'EURLACCESS';
+export const EFETCH = 'EFETCH';

package/dist/node_modules/nodemailer/dist/esm/fetch/cookies.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Options for the Cookies jar
+ */
+export interface CookiesOptions {
+    /** Lifetime in seconds for cookies that do not set their own expiration (default 1800) */
+    sessionTimeout?: number | string | undefined;
+}
+/**
+ * A cookie as parsed from a 'Set-Cookie:' header and kept in the jar
+ */
+export interface Cookie {
+    name?: string | undefined;
+    value?: string | undefined;
+    domain?: string | undefined;
+    path?: string | undefined;
+    expires?: Date | undefined;
+    secure?: boolean | undefined;
+    httponly?: boolean | undefined;
+}
+type CookieEntry = Cookie;
+/**
+ * Creates a biskviit cookie jar for managing cookie values in memory
+ *
+ * @constructor
+ * @param [options] Optional options object
+ */
+declare class Cookies {
+    options: CookiesOptions;
+    cookies: Cookie[];
+    constructor(options?: CookiesOptions);
+    /**
+     * Stores a cookie string to the cookie storage
+     *
+     * @param cookieStr Value from the 'Set-Cookie:' header
+     * @param url Current URL
+     */
+    set(cookieStr: string, url?: string): boolean;
+    /**
+     * Returns cookie string for the 'Cookie:' header.
+     *
+     * @param url URL to check for
+     * @returns Cookie header or empty string if no matches were found
+     */
+    get(url?: string): string;
+    /**
+     * Lists all valied cookie objects for the specified URL
+     *
+     * @param url URL to check for
+     * @returns An array of cookie objects
+     */
+    list(url?: string): Cookie[];
+    /**
+     * Parses cookie string from the 'Set-Cookie:' header
+     *
+     * @param cookieStr String from the 'Set-Cookie:' header
+     * @returns Cookie object
+     */
+    parse(cookieStr?: string): Cookie;
+    /**
+     * Checks if a cookie object is valid for a specified URL
+     *
+     * @param cookie Cookie object
+     * @param url URL to check for
+     * @returns true if cookie is valid for specifiec URL
+     */
+    match(cookie: Cookie, url?: string): boolean;
+    /**
+     * Adds (or updates/removes if needed) a cookie object to the cookie storage
+     *
+     * @param cookie Cookie value to be stored
+     */
+    add(cookie: Cookie): boolean;
+    /**
+     * Checks if two cookie objects are the same
+     *
+     * @param a Cookie to check against
+     * @param b Cookie to check against
+     * @returns True, if the cookies are the same
+     */
+    compare(a: Cookie, b: Cookie): boolean;
+    /**
+     * Checks if a cookie is expired
+     *
+     * @param cookie Cookie object to check against
+     * @returns True, if the cookie is expired
+     */
+    isExpired(cookie: Cookie): boolean;
+    /**
+     * Returns the default path for an URL path argument, the default-path of
+     * RFC 6265 section 5.1.4. A cookie that carries no Path attribute is scoped
+     * to the directory of the URL it was set from
+     *
+     * @param pathname
+     * @returns Default path
+     */
+    getPath(pathname?: string | null): string;
+}
+/**
+ * Type aliases in the layout of @types/nodemailer, so `Cookies.Cookie` style references keep working
+ */
+declare namespace Cookies {
+    type Options = CookiesOptions;
+    type Cookie = CookieEntry;
+}
+/** The same alias as a module level export, for `import * as Cookies` and `import Cookies = require()` */
+export type { CookiesOptions as Options };
+export default Cookies;

package/dist/node_modules/nodemailer/dist/esm/fetch/cookies.js

@@ -0,0 +1,242 @@
+// module to handle cookies
+import net from 'node:net';
+import * as urllib from '../shared/url.js';
+const SESSION_TIMEOUT = 1800; // 30 min
+/**
+ * Creates a biskviit cookie jar for managing cookie values in memory
+ *
+ * @constructor
+ * @param [options] Optional options object
+ */
+class Cookies {
+    constructor(options) {
+        this.options = options || {};
+        this.cookies = [];
+    }
+    /**
+     * Stores a cookie string to the cookie storage
+     *
+     * @param cookieStr Value from the 'Set-Cookie:' header
+     * @param url Current URL
+     */
+    set(cookieStr, url) {
+        const urlparts = urllib.parse(url || '');
+        const cookie = this.parse(cookieStr);
+        let domain;
+        if (cookie.domain) {
+            domain = cookie.domain.replace(/^\./, '');
+            // do not allow cross origin cookies. There is no public suffix list here, so a
+            // multi-label suffix like 'co.uk' can not be told apart from a registrable domain
+            if (
+            // can't be valid if the requested domain is shorter than current hostname
+            urlparts.hostname.length < domain.length ||
+                // a top level domain is not a valid scope, 'Domain=com' would otherwise be
+                // sent to every .com host. A trailing dot does not make 'com.' any better
+                domain.indexOf('.') < 0 ||
+                domain.endsWith('.') ||
+                // an IP address has no subdomains, so cookies set on it stay host-only
+                net.isIP(urlparts.hostname) ||
+                // prefix domains with dot to be sure that partial matches are not used
+                !('.' + urlparts.hostname).endsWith('.' + domain)) {
+                cookie.domain = urlparts.hostname;
+            }
+        }
+        else {
+            cookie.domain = urlparts.hostname;
+        }
+        if (!cookie.path) {
+            cookie.path = this.getPath(urlparts.pathname);
+        }
+        // if no expire date, then use sessionTimeout value
+        if (!cookie.expires) {
+            cookie.expires = new Date(Date.now() + (Number(this.options.sessionTimeout || SESSION_TIMEOUT) || SESSION_TIMEOUT) * 1000);
+        }
+        return this.add(cookie);
+    }
+    /**
+     * Returns cookie string for the 'Cookie:' header.
+     *
+     * @param url URL to check for
+     * @returns Cookie header or empty string if no matches were found
+     */
+    get(url) {
+        return this.list(url)
+            .map(cookie => cookie.name + '=' + cookie.value)
+            .join('; ');
+    }
+    /**
+     * Lists all valied cookie objects for the specified URL
+     *
+     * @param url URL to check for
+     * @returns An array of cookie objects
+     */
+    list(url) {
+        const result = [];
+        for (let i = this.cookies.length - 1; i >= 0; i--) {
+            const cookie = this.cookies[i];
+            if (this.isExpired(cookie)) {
+                this.cookies.splice(i, 1);
+                continue;
+            }
+            if (this.match(cookie, url)) {
+                result.unshift(cookie);
+            }
+        }
+        return result;
+    }
+    /**
+     * Parses cookie string from the 'Set-Cookie:' header
+     *
+     * @param cookieStr String from the 'Set-Cookie:' header
+     * @returns Cookie object
+     */
+    parse(cookieStr) {
+        const cookie = {};
+        (cookieStr || '')
+            .toString()
+            .split(';')
+            .forEach(cookiePart => {
+            const valueParts = cookiePart.split('=');
+            const key = valueParts.shift().trim().toLowerCase();
+            let value = valueParts.join('=').trim();
+            let domain;
+            if (!key) {
+                // skip empty parts
+                return;
+            }
+            switch (key) {
+                case 'expires': {
+                    const expires = new Date(value);
+                    // ignore date if can not parse it
+                    if (expires.toString() !== 'Invalid Date') {
+                        cookie.expires = expires;
+                    }
+                    break;
+                }
+                case 'path':
+                    cookie.path = value;
+                    break;
+                case 'domain':
+                    domain = value.toLowerCase();
+                    if (domain.length && domain.charAt(0) !== '.') {
+                        domain = '.' + domain; // ensure preceeding dot for user set domains
+                    }
+                    cookie.domain = domain;
+                    break;
+                case 'max-age':
+                    cookie.expires = new Date(Date.now() + (Number(value) || 0) * 1000);
+                    break;
+                case 'secure':
+                    cookie.secure = true;
+                    break;
+                case 'httponly':
+                    cookie.httponly = true;
+                    break;
+                default:
+                    if (!cookie.name) {
+                        cookie.name = key;
+                        cookie.value = value;
+                    }
+            }
+        });
+        return cookie;
+    }
+    /**
+     * Checks if a cookie object is valid for a specified URL
+     *
+     * @param cookie Cookie object
+     * @param url URL to check for
+     * @returns true if cookie is valid for specifiec URL
+     */
+    match(cookie, url) {
+        const urlparts = urllib.parse(url || '');
+        // check if hostname matches
+        // .foo.com also matches subdomains, foo.com does not
+        if (urlparts.hostname !== cookie.domain &&
+            (cookie.domain.charAt(0) !== '.' ||
+                ('.' + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)) {
+            return false;
+        }
+        // check if the request path path-matches the cookie path (RFC 6265 section 5.1.4):
+        // identical paths match, otherwise the cookie path must be a directory prefix
+        const pathname = urlparts.pathname || '/';
+        const cookiePath = cookie.path;
+        const pathMatches = pathname === cookiePath ||
+            (pathname.startsWith(cookiePath) && (cookiePath.endsWith('/') || pathname.charAt(cookiePath.length) === '/'));
+        if (!pathMatches) {
+            return false;
+        }
+        // check secure argument
+        if (cookie.secure && urlparts.protocol !== 'https:') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Adds (or updates/removes if needed) a cookie object to the cookie storage
+     *
+     * @param cookie Cookie value to be stored
+     */
+    add(cookie) {
+        // nothing to do here
+        if (!cookie || !cookie.name) {
+            return false;
+        }
+        // overwrite if has same params
+        for (let i = 0, len = this.cookies.length; i < len; i++) {
+            if (this.compare(this.cookies[i], cookie)) {
+                // check if the cookie needs to be removed instead
+                if (this.isExpired(cookie)) {
+                    this.cookies.splice(i, 1); // remove expired/unset cookie
+                    return false;
+                }
+                this.cookies[i] = cookie;
+                return true;
+            }
+        }
+        // add as new if not already expired
+        if (!this.isExpired(cookie)) {
+            this.cookies.push(cookie);
+        }
+        return true;
+    }
+    /**
+     * Checks if two cookie objects are the same
+     *
+     * @param a Cookie to check against
+     * @param b Cookie to check against
+     * @returns True, if the cookies are the same
+     */
+    compare(a, b) {
+        return a.name === b.name && a.path === b.path && a.domain === b.domain && a.secure === b.secure && a.httponly === b.httponly;
+    }
+    /**
+     * Checks if a cookie is expired
+     *
+     * @param cookie Cookie object to check against
+     * @returns True, if the cookie is expired
+     */
+    isExpired(cookie) {
+        return (cookie.expires && cookie.expires < new Date()) || !cookie.value;
+    }
+    /**
+     * Returns the default path for an URL path argument, the default-path of
+     * RFC 6265 section 5.1.4. A cookie that carries no Path attribute is scoped
+     * to the directory of the URL it was set from
+     *
+     * @param pathname
+     * @returns Default path
+     */
+    getPath(pathname) {
+        const pathParts = (pathname || '/').split('/');
+        pathParts.pop(); // remove filename part
+        const path = pathParts.join('/').trim();
+        // a path that holds no more than one '/' is scoped to the root path, and so
+        // is one that does not start with '/' at all
+        if (path.charAt(0) !== '/') {
+            return '/';
+        }
+        return path;
+    }
+}
+export default Cookies;

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

@@ -0,0 +1,65 @@
+import http from 'node:http';
+import { PassThrough, type Readable } from 'node:stream';
+import Cookies from './cookies.js';
+/**
+ * Options for nmfetch
+ */
+export interface FetchOptions {
+    /** HTTP method, defaults to GET, or to POST when a body is given */
+    method?: string | undefined;
+    /** Request headers, keys are lowercased before use */
+    headers?: http.OutgoingHttpHeaders | undefined;
+    /** Overrides the default User-Agent header */
+    userAgent?: string | undefined;
+    /** Cookie string(s) to seed the cookie jar with for this URL */
+    cookie?: string | string[] | false | undefined;
+    /** Cookie jar shared across redirects, created when missing */
+    cookies?: Cookies | undefined;
+    /** Request body: a readable stream, a Buffer, a form object or a string */
+    body?: Readable | Buffer | {
+        [key: string]: any;
+    } | string | false | undefined;
+    /** Content-Type header for the body, false leaves it out for a stream body */
+    contentType?: string | false | undefined;
+    /** TLS settings, only the keys listed in TLS_OPTION_KEYS are used */
+    tls?: {
+        [key: string]: any;
+    } | undefined;
+    /** Socket inactivity timeout in milliseconds, defaults to 60000, 0 disables it */
+    timeout?: number | undefined;
+    /** Maximum size of the (decoded) response body in bytes, defaults to 64 MB, Infinity disables the limit */
+    maxBytes?: number | undefined;
+    /** Maximum number of redirects to follow (default 5) */
+    maxRedirects?: number | undefined;
+    /** Resolve responses with a status code of 300 or above instead of emitting an error */
+    allowErrorResponse?: boolean | undefined;
+    /** Redirects followed so far, set by nmfetch itself */
+    redirects?: number | undefined;
+    /** Response stream shared across redirects, set by nmfetch itself */
+    fetchRes?: FetchResponse | undefined;
+}
+/**
+ * The stream nmfetch returns. The response body is piped into it, the status code and
+ * headers of the final response are attached once they arrive
+ */
+export interface FetchResponse extends PassThrough {
+    statusCode?: number | undefined;
+    headers?: http.IncomingHttpHeaders | undefined;
+}
+declare function nmfetch(url: string, options?: FetchOptions): FetchResponse;
+declare namespace nmfetch {
+    var Cookies: typeof import("./cookies.js").default;
+    var DEFAULT_TIMEOUT: number;
+}
+type CookiesJar = Cookies;
+/**
+ * Type aliases in the layout of @types/nodemailer, so `fetch.Options` style references keep working
+ */
+declare namespace nmfetch {
+    type Options = FetchOptions;
+    type WritableResponse = FetchResponse;
+    type Cookies = CookiesJar;
+}
+/** The same aliases as module level exports, for `import * as fetch` and `import fetch = require()` */
+export type { FetchOptions as Options, FetchResponse as WritableResponse, Cookies };
+export default nmfetch;