@mavogel/awscdk-rootmail 0.1.4 → 0.1.6

package/node_modules/nodemailer/dist/esm/mailer/index.js

@@ -134,12 +134,24 @@ class Mail extends EventEmitter {
                 }, 'PluginCompile Error: %s', err.message);
                 return done(err);
             }
-            mail.message = new MailComposer(mail.data).compile();
-            mail.setMailerHeader();
-            mail.setPriorityHeaders();
-            mail.setListHeaders();
+            let recipientCount;
+            try {
+                mail.message = new MailComposer(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;
@@ -187,6 +199,7 @@ class Mail extends EventEmitter {
     getVersionString() {
         return util.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)) {
@@ -321,6 +334,7 @@ class Mail extends EventEmitter {
             callback(err);
         };
     }
+    /** @internal */
     _convertDataImages(mail, callback) {
         if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) {
             return callback();

package/node_modules/nodemailer/dist/esm/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/node_modules/nodemailer/dist/esm/mailer/mail-message.js

@@ -69,8 +69,9 @@ export default class MailMessage {
         if (this.data.attachments && this.data.attachments.length) {
             this.data.attachments.forEach((attachment, i) => {
                 if (!attachment.filename) {
+                    // a backslash separates as well, so a Windows path does not put the sender's directories in the headers
                     attachment.filename =
-                        (attachment.path || attachment.href || '').split('/').pop().split('?').shift() ||
+                        (attachment.path || attachment.href || '').split(/[/\\]/).pop().split('?').shift() ||
                             'attachment-' + (i + 1);
                     if (attachment.filename.indexOf('.') < 0) {
                         attachment.filename += '.' + mimeFuncs.detectExtension(attachment.contentType);
@@ -239,6 +240,7 @@ export default class MailMessage {
             });
         });
     }
+    /** @internal */
     _getListHeaders(listData) {
         // make sure an url looks like <protocol:url>
         return Object.keys(listData).map(key => ({
@@ -283,6 +285,7 @@ export default 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/node_modules/nodemailer/dist/esm/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/node_modules/nodemailer/dist/esm/mime-funcs/index.js

@@ -76,7 +76,10 @@ export function encodeWord(data, mimeWordEncoding, maxLength) {
         });
     }
     else if (mimeWordEncoding === 'B') {
-        encodedStr = typeof data === 'string' ? data : base64.encode(data);
+        // the chunking loop below splits raw text and base64 encodes each part, so a
+        // Buffer goes in as its UTF-8 string: handing it the base64 of the whole input
+        // would encode the encoding itself and decode back to base64 text
+        encodedStr = typeof data === 'string' ? data : data.toString('utf-8');
         maxLength = maxLength ? Math.max(3, ((maxLength - (maxLength % 4)) / 4) * 3) : 0;
     }
     if (maxLength && (mimeWordEncoding !== 'B' ? encodedStr : base64.encode(data)).length > maxLength) {

package/node_modules/nodemailer/dist/esm/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