velocious 1.0.431 → 1.0.433

package/build/src/mailer/backends/smtp.js

@@ -1,22 +1,20 @@
 // @ts-check
-
-import restArgsError from "../../utils/rest-args-error.js"
-
+import restArgsError from "../../utils/rest-args-error.js";
 /**
  * Defines this typedef.
   @typedef {{auth?: Record<string, ?>, [key: string]: ?}} SmtpConnectionOptions */
-
 /**
  * Runs normalize recipients.
  * @param {?} value - Recipient input.
  * @returns {string[]} - Normalized recipients.
  */
 function normalizeRecipients(value) {
-  if (!value) return []
-  if (Array.isArray(value)) return value.filter((entry) => entry)
-  return [value].filter((entry) => entry)
+    if (!value)
+        return [];
+    if (Array.isArray(value))
+        return value.filter((entry) => entry);
+    return [value].filter((entry) => entry);
 }
-
 /**
  * Runs header line.
  * @param {string} name - Header name.
@@ -24,174 +22,147 @@ function normalizeRecipients(value) {
  * @returns {string | null} - Header line.
  */
 function headerLine(name, value) {
-  if (!value) return null
-
-  return `${name}: ${value}`
+    if (!value)
+        return null;
+    return `${name}: ${value}`;
 }
-
 /**
  * Runs envelope address.
  * @param {string} address - Header or mailbox address.
  * @returns {string} - SMTP envelope mailbox.
  */
 function envelopeAddress(address) {
-  const match = address.match(/<([^<>]+)>/)
-
-  return (match ? match[1] : address).trim()
+    const match = address.match(/<([^<>]+)>/);
+    return (match ? match[1] : address).trim();
 }
-
 /**
  * SMTP mailer backend using smtp-connection.
  */
 export default class SmtpMailerBackend {
-  /**
-   * Runs constructor.
-   * @param {object} args - Constructor args.
-   * @param {SmtpConnectionOptions} args.connectionOptions - smtp-connection options.
-   * @param {string} [args.defaultFrom] - Default from address.
-   */
-  constructor({connectionOptions, defaultFrom, ...restArgs}) {
-    restArgsError(restArgs)
-
-    if (!connectionOptions) {
-      throw new Error(`Missing smtp connection options. Got: ${String(connectionOptions)}`)
-    }
-
-    this.connectionOptions = connectionOptions
-    this.defaultFrom = defaultFrom
-  }
-
-  /**
-   * Runs deliver.
-   * @param {object} args - Delivery args.
-   * @param {import("../index.js").MailerDeliveryPayload} args.payload - Mail delivery payload.
-   * @param {import("../../configuration.js").default} [args.configuration] - Active configuration.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async deliver({payload, configuration: _configuration, ...restArgs}) {
-    restArgsError(restArgs)
-
-    const from = payload.from || this.defaultFrom
-
-    if (!from) {
-      throw new Error(`Missing mail "from" address. Got: ${String(from)}`)
-    }
-
-    const envelopeFrom = envelopeAddress(String(from))
-
-    const toList = normalizeRecipients(payload.to)
-    const ccList = normalizeRecipients(payload.cc)
-    const bccList = normalizeRecipients(payload.bcc)
-    const recipients = [...toList, ...ccList, ...bccList]
-
-    if (recipients.length === 0) {
-      throw new Error(`Missing mail recipients. Got: ${JSON.stringify({to: payload.to, cc: payload.cc, bcc: payload.bcc})}`)
-    }
-
-    const headers = [
-      headerLine("From", from),
-      headerLine("To", toList.length > 0 ? toList.join(", ") : undefined),
-      headerLine("Cc", ccList.length > 0 ? ccList.join(", ") : undefined),
-      headerLine("Subject", payload.subject),
-      "MIME-Version: 1.0",
-      "Content-Type: text/html; charset=UTF-8"
-    ].filter((line) => line)
-
-    if (payload.headers) {
-      for (const [headerName, headerValue] of Object.entries(payload.headers)) {
-        headers.push(`${headerName}: ${headerValue}`)
-      }
+    /**
+     * Runs constructor.
+     * @param {object} args - Constructor args.
+     * @param {SmtpConnectionOptions} args.connectionOptions - smtp-connection options.
+     * @param {string} [args.defaultFrom] - Default from address.
+     */
+    constructor({ connectionOptions, defaultFrom, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!connectionOptions) {
+            throw new Error(`Missing smtp connection options. Got: ${String(connectionOptions)}`);
+        }
+        this.connectionOptions = connectionOptions;
+        this.defaultFrom = defaultFrom;
     }
-
-    const message = `${headers.join("\r\n")}\r\n\r\n${payload.html}`
-    const {default: SmtpConnection} = await import("smtp-connection")
-    const connectionOptions = this.connectionOptions
-    const connection = new SmtpConnection(connectionOptions)
-
-    await new Promise((resolve, reject) => {
-      let settled = false
-      let shuttingDown = false
-
-      const cleanup = () => {
-        connection.removeListener("end", onEnd)
-        connection.removeListener("error", onError)
-      }
-
-      const resolveDelivery = () => {
-        if (settled) return
-
-        settled = true
-        cleanup()
-        resolve(undefined)
-      }
-
-      /**
-       * Reject delivery.
-       * @param {Error} error - Error that failed delivery.
-       */
-      const rejectDelivery = (error) => {
-        if (settled) return
-
-        settled = true
-        cleanup()
-        connection.close()
-        reject(error)
-      }
-
-      const onEnd = () => resolveDelivery()
-
-      /**
-       * On error.
-       * @param {Error} error - Error emitted by the SMTP connection.
-       */
-      const onError = (error) => {
-        if (shuttingDown) {
-          resolveDelivery()
-          return
+    /**
+     * Runs deliver.
+     * @param {object} args - Delivery args.
+     * @param {import("../index.js").MailerDeliveryPayload} args.payload - Mail delivery payload.
+     * @param {import("../../configuration.js").default} [args.configuration] - Active configuration.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async deliver({ payload, configuration: _configuration, ...restArgs }) {
+        restArgsError(restArgs);
+        const from = payload.from || this.defaultFrom;
+        if (!from) {
+            throw new Error(`Missing mail "from" address. Got: ${String(from)}`);
+        }
+        const envelopeFrom = envelopeAddress(String(from));
+        const toList = normalizeRecipients(payload.to);
+        const ccList = normalizeRecipients(payload.cc);
+        const bccList = normalizeRecipients(payload.bcc);
+        const recipients = [...toList, ...ccList, ...bccList];
+        if (recipients.length === 0) {
+            throw new Error(`Missing mail recipients. Got: ${JSON.stringify({ to: payload.to, cc: payload.cc, bcc: payload.bcc })}`);
         }
-
-        rejectDelivery(error)
-      }
-
-      const quitAfterAcceptedMessage = () => {
-        shuttingDown = true
-        connection.once("end", onEnd)
-        connection.quit()
-      }
-
-      const sendMessage = () => {
-        connection.send({from: envelopeFrom, to: recipients}, /**
-                                                               * Narrows the runtime value to the documented type.
-                                                                @type {?} */ (message), (/**
-                                                                                          * Narrows the runtime value to the documented type.
-                                                                                           @type {Error | null | undefined} */ sendError) => {
-          if (sendError) {
-            rejectDelivery(sendError)
-            return
-          }
-
-          quitAfterAcceptedMessage()
-        })
-      }
-
-      const authenticateAndSend = () => {
-        if (!connectionOptions.auth) {
-          sendMessage()
-          return
+        const headers = [
+            headerLine("From", from),
+            headerLine("To", toList.length > 0 ? toList.join(", ") : undefined),
+            headerLine("Cc", ccList.length > 0 ? ccList.join(", ") : undefined),
+            headerLine("Subject", payload.subject),
+            "MIME-Version: 1.0",
+            "Content-Type: text/html; charset=UTF-8"
+        ].filter((line) => line);
+        if (payload.headers) {
+            for (const [headerName, headerValue] of Object.entries(payload.headers)) {
+                headers.push(`${headerName}: ${headerValue}`);
+            }
         }
-
-        connection.login(connectionOptions.auth, (loginError) => {
-          if (loginError) {
-            rejectDelivery(loginError)
-            return
-          }
-
-          sendMessage()
-        })
-      }
-
-      connection.on("error", onError)
-      connection.connect(authenticateAndSend)
-    })
-  }
+        const message = `${headers.join("\r\n")}\r\n\r\n${payload.html}`;
+        const { default: SmtpConnection } = await import("smtp-connection");
+        const connectionOptions = this.connectionOptions;
+        const connection = new SmtpConnection(connectionOptions);
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let shuttingDown = false;
+            const cleanup = () => {
+                connection.removeListener("end", onEnd);
+                connection.removeListener("error", onError);
+            };
+            const resolveDelivery = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(undefined);
+            };
+            /**
+             * Reject delivery.
+             * @param {Error} error - Error that failed delivery.
+             */
+            const rejectDelivery = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                connection.close();
+                reject(error);
+            };
+            const onEnd = () => resolveDelivery();
+            /**
+             * On error.
+             * @param {Error} error - Error emitted by the SMTP connection.
+             */
+            const onError = (error) => {
+                if (shuttingDown) {
+                    resolveDelivery();
+                    return;
+                }
+                rejectDelivery(error);
+            };
+            const quitAfterAcceptedMessage = () => {
+                shuttingDown = true;
+                connection.once("end", onEnd);
+                connection.quit();
+            };
+            const sendMessage = () => {
+                connection.send({ from: envelopeFrom, to: recipients }, /**
+                                                                       * Narrows the runtime value to the documented type.
+                                                                        @type {?} */ (message), (/**
+                                          * Narrows the runtime value to the documented type.
+                                           @type {Error | null | undefined} */ sendError) => {
+                    if (sendError) {
+                        rejectDelivery(sendError);
+                        return;
+                    }
+                    quitAfterAcceptedMessage();
+                });
+            };
+            const authenticateAndSend = () => {
+                if (!connectionOptions.auth) {
+                    sendMessage();
+                    return;
+                }
+                connection.login(connectionOptions.auth, (loginError) => {
+                    if (loginError) {
+                        rejectDelivery(loginError);
+                        return;
+                    }
+                    sendMessage();
+                });
+            };
+            connection.on("error", onError);
+            connection.connect(authenticateAndSend);
+        });
+    }
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smtp.js","sourceRoot":"","sources":["../../../../src/mailer/backends/smtp.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../utils/rest-args-error.js\"\n\n/**\n * Defines this typedef.\n  @typedef {{auth?: Record<string, ?>, [key: string]: ?}} SmtpConnectionOptions */\n\n/**\n * Runs normalize recipients.\n * @param {?} value - Recipient input.\n * @returns {string[]} - Normalized recipients.\n */\nfunction normalizeRecipients(value) {\n  if (!value) return []\n  if (Array.isArray(value)) return value.filter((entry) => entry)\n  return [value].filter((entry) => entry)\n}\n\n/**\n * Runs header line.\n * @param {string} name - Header name.\n * @param {string | undefined} value - Header value.\n * @returns {string | null} - Header line.\n */\nfunction headerLine(name, value) {\n  if (!value) return null\n\n  return `${name}: ${value}`\n}\n\n/**\n * Runs envelope address.\n * @param {string} address - Header or mailbox address.\n * @returns {string} - SMTP envelope mailbox.\n */\nfunction envelopeAddress(address) {\n  const match = address.match(/<([^<>]+)>/)\n\n  return (match ? match[1] : address).trim()\n}\n\n/**\n * SMTP mailer backend using smtp-connection.\n */\nexport default class SmtpMailerBackend {\n  /**\n   * Runs constructor.\n   * @param {object} args - Constructor args.\n   * @param {SmtpConnectionOptions} args.connectionOptions - smtp-connection options.\n   * @param {string} [args.defaultFrom] - Default from address.\n   */\n  constructor({connectionOptions, defaultFrom, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!connectionOptions) {\n      throw new Error(`Missing smtp connection options. Got: ${String(connectionOptions)}`)\n    }\n\n    this.connectionOptions = connectionOptions\n    this.defaultFrom = defaultFrom\n  }\n\n  /**\n   * Runs deliver.\n   * @param {object} args - Delivery args.\n   * @param {import(\"../index.js\").MailerDeliveryPayload} args.payload - Mail delivery payload.\n   * @param {import(\"../../configuration.js\").default} [args.configuration] - Active configuration.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async deliver({payload, configuration: _configuration, ...restArgs}) {\n    restArgsError(restArgs)\n\n    const from = payload.from || this.defaultFrom\n\n    if (!from) {\n      throw new Error(`Missing mail \"from\" address. Got: ${String(from)}`)\n    }\n\n    const envelopeFrom = envelopeAddress(String(from))\n\n    const toList = normalizeRecipients(payload.to)\n    const ccList = normalizeRecipients(payload.cc)\n    const bccList = normalizeRecipients(payload.bcc)\n    const recipients = [...toList, ...ccList, ...bccList]\n\n    if (recipients.length === 0) {\n      throw new Error(`Missing mail recipients. Got: ${JSON.stringify({to: payload.to, cc: payload.cc, bcc: payload.bcc})}`)\n    }\n\n    const headers = [\n      headerLine(\"From\", from),\n      headerLine(\"To\", toList.length > 0 ? toList.join(\", \") : undefined),\n      headerLine(\"Cc\", ccList.length > 0 ? ccList.join(\", \") : undefined),\n      headerLine(\"Subject\", payload.subject),\n      \"MIME-Version: 1.0\",\n      \"Content-Type: text/html; charset=UTF-8\"\n    ].filter((line) => line)\n\n    if (payload.headers) {\n      for (const [headerName, headerValue] of Object.entries(payload.headers)) {\n        headers.push(`${headerName}: ${headerValue}`)\n      }\n    }\n\n    const message = `${headers.join(\"\\r\\n\")}\\r\\n\\r\\n${payload.html}`\n    const {default: SmtpConnection} = await import(\"smtp-connection\")\n    const connectionOptions = this.connectionOptions\n    const connection = new SmtpConnection(connectionOptions)\n\n    await new Promise((resolve, reject) => {\n      let settled = false\n      let shuttingDown = false\n\n      const cleanup = () => {\n        connection.removeListener(\"end\", onEnd)\n        connection.removeListener(\"error\", onError)\n      }\n\n      const resolveDelivery = () => {\n        if (settled) return\n\n        settled = true\n        cleanup()\n        resolve(undefined)\n      }\n\n      /**\n       * Reject delivery.\n       * @param {Error} error - Error that failed delivery.\n       */\n      const rejectDelivery = (error) => {\n        if (settled) return\n\n        settled = true\n        cleanup()\n        connection.close()\n        reject(error)\n      }\n\n      const onEnd = () => resolveDelivery()\n\n      /**\n       * On error.\n       * @param {Error} error - Error emitted by the SMTP connection.\n       */\n      const onError = (error) => {\n        if (shuttingDown) {\n          resolveDelivery()\n          return\n        }\n\n        rejectDelivery(error)\n      }\n\n      const quitAfterAcceptedMessage = () => {\n        shuttingDown = true\n        connection.once(\"end\", onEnd)\n        connection.quit()\n      }\n\n      const sendMessage = () => {\n        connection.send({from: envelopeFrom, to: recipients}, /**\n                                                               * Narrows the runtime value to the documented type.\n                                                                @type {?} */ (message), (/**\n                                                                                          * Narrows the runtime value to the documented type.\n                                                                                           @type {Error | null | undefined} */ sendError) => {\n          if (sendError) {\n            rejectDelivery(sendError)\n            return\n          }\n\n          quitAfterAcceptedMessage()\n        })\n      }\n\n      const authenticateAndSend = () => {\n        if (!connectionOptions.auth) {\n          sendMessage()\n          return\n        }\n\n        connection.login(connectionOptions.auth, (loginError) => {\n          if (loginError) {\n            rejectDelivery(loginError)\n            return\n          }\n\n          sendMessage()\n        })\n      }\n\n      connection.on(\"error\", onError)\n      connection.connect(authenticateAndSend)\n    })\n  }\n}\n"]}