nodemailer 10.0.0 → 10.0.2

package/dist/cjs/mailer/index.d.ts

@@ -25,13 +25,13 @@ export interface SentMessageInfo {
     /** Message-ID of the sent message */
     messageId: string;
     /** Recipient addresses the transport accepted */
-    accepted?: string[];
+    accepted?: string[] | undefined;
     /** Recipient addresses the transport rejected */
-    rejected?: string[];
+    rejected?: string[] | undefined;
     /** Recipient addresses left pending, LMTP reports these */
-    pending?: string[];
+    pending?: string[] | undefined;
     /** Last response from the server */
-    response?: string;
+    response?: string | undefined;
     /** The generated message, for the transports that hand it back instead of sending it */
     message?: unknown;
     /** Transport specific fields */
@@ -59,8 +59,8 @@ export type PluginFunction<T = SentMessageInfo> = (mail: MailMessage<T>, callbac
  * the socket, with the host and port to connect to
  */
 export interface GetSocketOptions {
-    host?: string;
-    port?: number | string;
+    host?: string | undefined;
+    port?: number | string | undefined;
     [key: string]: any;
 }
 /**
@@ -68,7 +68,7 @@ export interface GetSocketOptions {
  */
 export interface SocketOptions {
     /** An established socket, the proxied connection */
-    connection?: net.Socket;
+    connection?: net.Socket | undefined;
 }
 /**
  * Receives the socket options from a getSocket handler, or the error that prevented the
@@ -119,9 +119,9 @@ export interface Transport<T = SentMessageInfo> {
     /** Registers an event listener, the transport may emit 'log', 'error', 'idle' and 'clear' */
     on?(event: string | symbol, listener: (...args: any[]) => void): this;
     /** The Mail object the transport belongs to, set by Mail */
-    mailer?: Mail<T>;
+    mailer?: Mail<T> | undefined;
     /** Socket handler for a proxied connection, set by Mail when a proxy is configured */
-    getSocket?: GetSocketHandler;
+    getSocket?: GetSocketHandler | undefined;
 }
 /**
  * Transport configuration as read by Mail itself. The transport reads its own options from
@@ -129,25 +129,25 @@ export interface Transport<T = SentMessageInfo> {
  */
 export interface TransportOptions {
     /** Bunyan compatible logger, true for the default console logger, false or unset for no logging */
-    logger?: shared.ExternalLogger | boolean;
+    logger?: shared.ExternalLogger | boolean | undefined;
     /** Component name for the log lines, defaults to 'mail' */
-    component?: string;
+    component?: string | undefined;
     /** DKIM signing options, every message is signed with these unless it carries its own */
-    dkim?: DKIMOptions;
+    dkim?: DKIMOptions | undefined;
     /** Proxy url. http(s) proxies work as is, socks proxies need the socks module set with set('proxy_socks_module', socks) */
-    proxy?: string;
+    proxy?: string | undefined;
     /** TLS options, rejectUnauthorized applies to an https proxy as well */
-    tls?: ConnectionOptions;
+    tls?: ConnectionOptions | undefined;
     /** Reject content that points to a file path, forced onto every message */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Reject content that points to a URL, forced onto every message */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
     /** Method to normalize header keys for custom caseing, forced onto every message */
-    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'];
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** Recipients allowed on one message, forced onto every message, 0 disables the limit, defaults to 100000 */
-    maxRecipients?: number;
+    maxRecipients?: number | undefined;
     /** Convert data: images in the html into embedded attachments */
-    attachDataUrls?: boolean;
+    attachDataUrls?: boolean | undefined;
 }
 /**
  * The transporter object createTransport returns, a Mail instance wrapping a transport
@@ -161,13 +161,8 @@ export type Transporter<T = SentMessageInfo> = Mail<T>;
  */
 declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     options: TransportOptions;
+    /** Message defaults given to createTransport, kept public because the DefinitelyTyped typings declared it */
     _defaults: MailDefaults;
-    _defaultPlugins: {
-        [step: string]: PluginFunction<any>[];
-    };
-    _userPlugins: {
-        [step: string]: PluginFunction<any>[];
-    };
     meta: Map<string, any>;
     dkim: DKIM | false;
     transporter: Transport<T>;
@@ -182,7 +177,7 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
         (): Promise<true>;
     };
     /** Socket handler for a proxied connection, set by setupProxy and handed to the transport on the next send */
-    getSocket?: GetSocketHandler | false;
+    getSocket?: GetSocketHandler | false | undefined;
     constructor(transporter: Transport<T>, options?: TransportOptions, defaults?: MailDefaults);
     use(step: string, plugin: PluginFunction<T>): this;
     /**
@@ -194,14 +189,12 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     sendMail(data: SendMailOptions): Promise<T>;
     sendMail(data: SendMailOptions, callback: SendMailCallback<T>): void;
     getVersionString(): string;
-    _processPlugins(step: string, mail: MailMessage<T>, callback: PluginCallback): void;
     /**
      * Sets up proxy handler for a Nodemailer object
      *
      * @param proxyUrl Proxy configuration url
      */
     setupProxy(proxyUrl: string): void;
-    _convertDataImages(mail: MailMessage<T>, callback: PluginCallback): void;
     set<K extends keyof MailMeta & string>(key: K, value: MailMeta[K]): Map<string, any>;
     get<K extends keyof MailMeta & string>(key: K): MailMeta[K] | undefined;
 }

package/dist/cjs/mailer/index.js

@@ -172,12 +172,24 @@ class Mail extends node_events_1.EventEmitter {
                 }, 'PluginCompile Error: %s', err.message);
                 return done(err);
             }
-            mail.message = new index_js_1.default(mail.data).compile();
-            mail.setMailerHeader();
-            mail.setPriorityHeaders();
-            mail.setListHeaders();
+            let recipientCount;
+            try {
+                mail.message = new index_js_1.default(mail.data).compile();
+                mail.setMailerHeader();
+                mail.setPriorityHeaders();
+                mail.setListHeaders();
+                recipientCount = mail.message.getEnvelope().to.length;
+            }
+            catch (err) {
+                // message data can throw while it is compiled, the error belongs to the callback
+                this.logger.error({
+                    err,
+                    tnx: 'transport',
+                    action: 'send'
+                }, 'Compile Error: %s', err.message);
+                return done(err);
+            }
             const maxRecipients = mail.data.maxRecipients === undefined ? DEFAULT_MAX_RECIPIENTS : mail.data.maxRecipients;
-            const recipientCount = mail.message.getEnvelope().to.length;
             if (maxRecipients && recipientCount > maxRecipients) {
                 const err = new Error(`Message has ${recipientCount} recipients, which is over the ${maxRecipients} allowed by maxRecipients`);
                 err.code = errors.EMAXRECIPIENTS;
@@ -225,6 +237,7 @@ class Mail extends node_events_1.EventEmitter {
     getVersionString() {
         return node_util_1.default.format('%s (%s; +%s; %s/%s)', packageData.name, packageData.version, packageData.homepage, this.transporter.name, this.transporter.version);
     }
+    /** @internal */
     _processPlugins(step, mail, callback) {
         step = (step || '').toString();
         if (!this._userPlugins.hasOwnProperty(step)) {
@@ -359,6 +372,7 @@ class Mail extends node_events_1.EventEmitter {
             callback(err);
         };
     }
+    /** @internal */
     _convertDataImages(mail, callback) {
         if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) {
             return callback();

package/dist/cjs/mailer/mail-message.d.ts

@@ -1,5 +1,5 @@
 import MimeNode, { type MimeNodePreparedHeaderValue } from '../mime-node/index.js';
-import type { MailComposerListHeaders, MailComposerOptions } from '../mail-composer/index.js';
+import type { MailComposerOptions } from '../mail-composer/index.js';
 import type { DKIMOptions } from '../dkim/index.js';
 import type { SMTPEnvelopeDsn } from '../smtp-connection/index.js';
 import type { SMTPTransportAuthOptions } from '../smtp-transport/index.js';
@@ -13,21 +13,19 @@ import type { SentMessageInfo } from './index.js';
  */
 export interface SendMailOptions extends MailComposerOptions {
     /** DKIM signing options for this message, used instead of the ones of the transporter */
-    dkim?: DKIMOptions;
-    /** Extra DKIM options for this message, merged over the options of the signer */
-    _dkim?: DKIMOptions;
+    dkim?: DKIMOptions | undefined;
     /** Recipients allowed on this message, 0 disables the limit, defaults to 100000 */
-    maxRecipients?: number;
+    maxRecipients?: number | undefined;
     /** SMTP transports: DSN parameters for the envelope, sent when the server supports the DSN extension */
-    dsn?: SMTPEnvelopeDsn;
+    dsn?: SMTPEnvelopeDsn | undefined;
     /** SMTP transports: RFC 8689, send the REQUIRETLS parameter with MAIL FROM */
-    requireTLSExtensionEnabled?: boolean;
+    requireTLSExtensionEnabled?: boolean | undefined;
     /** SMTP transports: per-message authentication settings, used instead of the transport level auth */
-    auth?: SMTPTransportAuthOptions;
+    auth?: SMTPTransportAuthOptions | undefined;
     /** SES transport: extra SendEmailCommand parameters merged into the API call */
     ses?: {
         [key: string]: unknown;
-    };
+    } | undefined;
 }
 /**
  * Default message fields, the third argument of createTransport. Applied to every message
@@ -43,7 +41,7 @@ export interface MailMessageData extends SendMailOptions {
     /** Header values flattened to strings and keyed by lowercase header name, set by normalize */
     normalizedHeaders?: {
         [key: string]: string;
-    };
+    } | undefined;
 }
 /**
  * Callback for resolveAll and normalize, receives the message data with every content value
@@ -89,6 +87,4 @@ export default class MailMessage<T = SentMessageInfo> {
     setMailerHeader(): void;
     setPriorityHeaders(): void;
     setListHeaders(): void;
-    _getListHeaders(listData: MailComposerListHeaders): MailMessageListHeader[];
-    _formatListUrl(url: string): string;
 }

package/dist/cjs/mailer/mail-message.js

@@ -277,6 +277,7 @@ class MailMessage {
             });
         });
     }
+    /** @internal */
     _getListHeaders(listData) {
         // make sure an url looks like <protocol:url>
         return Object.keys(listData).map(key => ({
@@ -321,6 +322,7 @@ class MailMessage {
             }))
         }));
     }
+    /** @internal */
     _formatListUrl(url) {
         // a url has no way to carry a control char or DEL, and the angle brackets around it
         // are not a quoting construct, so anything left here lands in the header raw

package/dist/cjs/mime-funcs/index.d.ts

@@ -14,7 +14,7 @@ export interface StructuredHeaderValue {
     /** The value ahead of the parameters, for example the content type */
     value: string | false;
     /** Parameter values keyed by parameter name */
-    params?: Record<string, string>;
+    params?: Record<string, string> | undefined;
 }
 /**
  * A single key=value pair of an rfc2231 encoded header parameter

package/dist/cjs/mime-node/index.d.ts

@@ -1,6 +1,4 @@
 import { type Duplex, type Readable, type TransformOptions, type Writable } from 'node:stream';
-import * as mimeFuncs from '../mime-funcs/index.js';
-import { type Address } from '../addressparser/index.js';
 import type { NodemailerError } from '../errors.js';
 import type { OutgoingHttpHeaders } from 'node:http';
 /**
@@ -8,38 +6,38 @@ import type { OutgoingHttpHeaders } from 'node:http';
  */
 export interface MimeNodeOptions {
     /** root node for this tree */
-    rootNode?: MimeNode;
+    rootNode?: MimeNode | undefined;
     /** immediate parent for this node */
-    parentNode?: MimeNode;
+    parentNode?: MimeNode | undefined;
     /** filename for an attachment node */
-    filename?: string;
+    filename?: string | undefined;
     /** shared part of the unique multipart boundary */
-    baseBoundary?: string;
+    baseBoundary?: string | undefined;
     /** prefix for the generated multipart boundaries, defaults to '--_NmP' */
-    boundaryPrefix?: string;
+    boundaryPrefix?: string | undefined;
     /** If true, do not exclude Bcc from the generated headers */
-    keepBcc?: boolean;
+    keepBcc?: boolean | undefined;
     /** method to normalize header keys for custom caseing */
-    normalizeHeaderKey?: (key: string, value: string) => string;
+    normalizeHeaderKey?: ((key: string, value: string) => string) | undefined;
     /** either 'Q' (the default) or 'B' */
-    textEncoding?: string;
+    textEncoding?: string | undefined;
     /** Hostname for default message-id values */
-    hostname?: string;
+    hostname?: string | undefined;
     /** If set to 'win' then uses \r\n, if 'linux' then \n. If not set (or `raw` is used) then newlines are kept as is */
-    newline?: string;
+    newline?: string | undefined;
     /** Reject content that points to a file path, for this node and every node below it */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Reject content that points to a URL, for this node and every node below it */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
 }
 /**
  * An address object as accepted in address headers and produced by getAddresses. Either a
  * mailbox with an address or a group holding a list of addresses
  */
 export interface MimeNodeAddress {
-    name?: string;
-    address?: string;
-    group?: MimeNodeAddress[];
+    name?: string | undefined;
+    address?: string | undefined;
+    group?: MimeNodeAddress[] | undefined;
 }
 /**
  * Addresses as accepted by address headers and envelope fields: an address string, an
@@ -52,8 +50,8 @@ export type MimeNodeAddressInput = string | MimeNodeAddress | MimeNodeAddressInp
  */
 export interface MimeNodePreparedHeaderValue {
     value?: unknown;
-    prepared?: boolean;
-    foldLines?: boolean;
+    prepared?: boolean | undefined;
+    foldLines?: boolean | undefined;
 }
 /**
  * The values a header can hold: a string, a number, a Date (for the Date header), address
@@ -84,19 +82,15 @@ export type MimeNodeHeaders = MimeNodeHeader | MimeNodeHeader[] | MimeNodeHeader
  */
 export interface MimeNodeContentObject {
     /** File path to read the content from */
-    path?: string;
+    path?: string | undefined;
     /** URL to fetch the content from */
-    href?: string;
+    href?: string | undefined;
     /** Request headers for a URL fetch */
-    httpHeaders?: OutgoingHttpHeaders;
+    httpHeaders?: OutgoingHttpHeaders | undefined;
     /** TLS settings for a URL fetch, see nmfetch */
     tls?: {
         [key: string]: any;
-    };
-    /** Read the content once and reuse the buffered value for every stream. MailComposer sets it on the icalEvent content, which is used twice */
-    _resolve?: boolean;
-    /** The buffered content once _resolve has run */
-    _resolvedValue?: Buffer;
+    } | undefined;
 }
 /**
  * Body content as accepted by setContent and setRaw: a string, a Buffer, a readable stream
@@ -117,22 +111,22 @@ export interface MimeNodeEnvelope {
  * other field is copied to the envelope as is
  */
 export interface MimeNodeEnvelopeInput {
-    from?: MimeNodeAddressInput;
-    to?: MimeNodeAddressInput;
-    cc?: MimeNodeAddressInput;
-    bcc?: MimeNodeAddressInput;
+    from?: MimeNodeAddressInput | undefined;
+    to?: MimeNodeAddressInput | undefined;
+    cc?: MimeNodeAddressInput | undefined;
+    bcc?: MimeNodeAddressInput | undefined;
     [key: string]: unknown;
 }
 /**
  * Parsed address headers as returned by getAddresses, keyed by lowercase header name
  */
 export interface MimeNodeAddresses {
-    from?: MimeNodeAddress[];
-    sender?: MimeNodeAddress[];
-    'reply-to'?: MimeNodeAddress[];
-    to?: MimeNodeAddress[];
-    cc?: MimeNodeAddress[];
-    bcc?: MimeNodeAddress[];
+    from?: MimeNodeAddress[] | undefined;
+    sender?: MimeNodeAddress[] | undefined;
+    'reply-to'?: MimeNodeAddress[] | undefined;
+    to?: MimeNodeAddress[] | undefined;
+    cc?: MimeNodeAddress[] | undefined;
+    bcc?: MimeNodeAddress[] | undefined;
 }
 /**
  * Options for createReadStream. Handed to the PassThrough the message is written to and to
@@ -140,7 +134,7 @@ export interface MimeNodeAddresses {
  */
 export interface MimeNodeStreamOptions extends TransformOptions {
     /** Maximum line length for base64 and quoted-printable bodies, false disables wrapping */
-    lineLength?: number | false;
+    lineLength?: number | false | undefined;
 }
 /**
  * A transform stream the message is piped through, or a function returning one
@@ -184,25 +178,16 @@ declare class MimeNode {
     hostname: string | undefined;
     newline: string | undefined;
     childNodes: MimeNode[];
-    _nodeId: number;
-    _headers: MimeNodeHeader[];
-    _isPlainText: boolean;
-    _hasLongLines: boolean;
-    _envelope: MimeNodeEnvelope | false;
-    _raw: MimeNodeContent | Error | false;
-    _transforms: MimeNodeTransform[];
-    _processFuncs: MimeNodeProcessFunc[];
     /** Filename for this node. Useful with attachments */
-    filename?: string;
+    filename?: string | undefined;
     /** Body content, or the error a content stream emitted before it was read */
-    content?: MimeNodeContent | Error;
+    content?: MimeNodeContent | Error | undefined;
     /** Lowercase content type, set when the headers are built */
-    contentType?: string;
+    contentType?: string | undefined;
     /** Multipart subtype, false for a non-multipart node, set when the headers are built */
-    multipart?: string | false;
+    multipart?: string | false | undefined;
     /** Multipart boundary, false for a non-multipart node, set when the headers are built */
-    boundary?: string | false;
-    _contentErrorHandler?: (err: Error) => void;
+    boundary?: string | false | undefined;
     constructor(contentType?: string | false, options?: MimeNodeOptions);
     /**
      * Creates and appends a child node.Arguments provided are passed to MimeNode constructor
@@ -333,145 +318,6 @@ declare class MimeNode {
      * @param raw Raw MIME contents
      */
     setRaw(raw: MimeNodeContent): this;
-    /**
-     * Checks an access policy flag for this node and every node above it. The flags are set
-     * from the options the node was built with, and createChild only ever sees the options
-     * the caller passed, so a child of a closed tree starts out open. Reading the answer off
-     * the parent chain keeps it right whatever order the tree was assembled in.
-     *
-     * @param flag Either 'disableFileAccess' or 'disableUrlAccess'
-     * @return true if this node or an ancestor closed that access
-     */
-    _accessDisabled(flag: 'disableFileAccess' | 'disableUrlAccess'): boolean;
-    /**
-     * Detects and returns handle to a stream related with the content.
-     *
-     * @param content Node content
-     * @returns Stream object
-     */
-    _getStream(content: any): Readable;
-    /**
-     * Parses addresses. Takes in a single address or an array or an
-     * array of address arrays (eg. To: [[first group], [second group],...])
-     *
-     * @param addresses Addresses to be parsed
-     * @return An array of address objects
-     */
-    _parseAddresses(addresses: MimeNodeAddressInput | undefined): MimeNodeAddress[];
-    /**
-     * Normalizes the addresses of a freshly parsed address list, groups included.
-     *
-     * Everything this method returns carries a normalized address, whether it arrived as an
-     * object or was parsed out of a header value. Without this the two shapes disagree, and
-     * a consumer reading the parsed form back is handed the ambiguous
-     * 'user@evil.com@good.com' that the header and the envelope no longer carry.
-     *
-     * @param parsed An array of address objects, as returned by addressparser
-     * @return The same array, with every address normalized
-     */
-    _normalizeParsedAddresses(parsed: Address[]): Address[];
-    /**
-     * Parses the addresses of an explicitly set envelope.
-     *
-     * An envelope value is an addr-spec and never a display name, so a bare local username
-     * such as 'root' is the address here. Header parsing has to read the same value as a
-     * display name, as a value with no '@' in it can not be an addr-spec in a header.
-     *
-     * @param addresses Addresses to be parsed
-     * @return An array of address objects
-     */
-    _parseEnvelopeAddresses(addresses: MimeNodeAddressInput | undefined): MimeNodeAddress[];
-    /**
-     * Normalizes a header key, uses Camel-Case form, except for uppercase MIME-
-     *
-     * @param key Key to be normalized
-     * @return key in Camel-Case form
-     */
-    _normalizeHeaderKey(key: string): string;
-    /**
-     * Checks if the content type is multipart and defines boundary if needed.
-     * Doesn't return anything, modifies object argument instead.
-     *
-     * @param structured Parsed header value for 'Content-Type' key
-     */
-    _handleContentType(structured: mimeFuncs.StructuredHeaderValue): void;
-    /**
-     * Generates a multipart boundary value
-     *
-     * @return boundary value
-     */
-    _generateBoundary(): string;
-    /**
-     * Encodes a header value for use in the generated rfc2822 email.
-     *
-     * @param key Header key
-     * @param value Header value
-     */
-    _encodeHeaderValue(key: string, value: MimeNodeHeaderValue): string;
-    /**
-     * Rebuilds address object using punycode and other adjustments
-     *
-     * @param addresses An array of address objects
-     * @param [uniqueList] An array to be populated with addresses
-     * @return address string
-     */
-    _convertAddresses(addresses: MimeNodeAddress | MimeNodeAddress[] | undefined, uniqueList?: MimeNodeAddress[], seenAddresses?: Set<string>): string;
-    /**
-     * Normalizes an email address
-     *
-     * @param address An array of address objects
-     * @return address string
-     */
-    _normalizeAddress(address?: string | false): string;
-    /**
-     * Normalizes the local part of an address into a form that can be emitted as is.
-     *
-     * A local part is either a dot-atom or a quoted-string, anything else is not a valid
-     * addr-spec. The quotes of a quoted local part get lost along the way, and a bare
-     * 'user@evil.com@good.com' leaves it to the receiver which '@' splits the domain off,
-     * while the split here is always at the last one. So whatever is not already one of
-     * the two valid forms goes back out as a quoted-string.
-     *
-     * @param user Local part of an address
-     * @return Local part as a dot-atom or as a quoted-string
-     */
-    _normalizeLocalPart(user: string): string;
-    /**
-     * If needed, mime encodes the name part
-     *
-     * @param name Name part of an address
-     * @returns Mime word encoded string if needed
-     */
-    _encodeAddressName(name: string): string;
-    /**
-     * Encodes an unstructured header value. Such a value can only carry VCHAR and WSP, so a
-     * control char or DEL has to be forced into the mime encoded word that a non-ascii value
-     * would get anyway. HT stays as it is, it is valid folding whitespace here.
-     *
-     * @param value Header value to encode
-     * @returns Mime word encoded string if needed
-     */
-    _encodeHeaderText(value: string): string;
-    /**
-     * If needed, mime encodes the name part
-     *
-     * @param name Name part of an address
-     * @returns Mime word encoded string if needed
-     */
-    _encodeWords(value: string): string;
-    /**
-     * Detects best mime encoding for a text value
-     *
-     * @param value Value to check for
-     * @return either 'Q' or 'B'
-     */
-    _getTextEncoding(value?: string | Buffer): string;
-    /**
-     * Generates a message id
-     *
-     * @return Random Message-ID value
-     */
-    _generateMessageId(): string;
 }
 /**
  * Type aliases in the layout of @types/nodemailer, so `MimeNode.Options` style references keep working