@ibgib/node-gib 0.0.9 → 0.0.13

package/src/email/aws/aws-sigv4-helper.mts

@@ -0,0 +1,139 @@
+/**
+ * AWS Signature Version 4 helper using native Node.js crypto module.
+ * Zero-dependency implementation for signing REST requests to AWS services (e.g., SES).
+ */
+
+import crypto from 'node:crypto';
+
+export interface AwsSigV4Options {
+    method: string;
+    url: string;
+    region: string;
+    service: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    body?: string | Buffer;
+    headers?: Record<string, string>;
+    timestamp?: Date;
+}
+
+export interface AwsSigV4Result {
+    headers: Record<string, string>;
+    amzDate: string;
+    signature: string;
+    authorization: string;
+}
+
+function sha256Hex(data: string | Buffer): string {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+function hmac(key: Buffer | string, data: string): Buffer {
+    return crypto.createHmac('sha256', key).update(data, 'utf8').digest();
+}
+
+function encodeRfc3986(str: string): string {
+    return encodeURIComponent(str).replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+/**
+ * Computes AWS SigV4 signed headers for an HTTP request.
+ */
+export function createAwsSigV4Headers(options: AwsSigV4Options): AwsSigV4Result {
+    const {
+        method,
+        url: urlStr,
+        region,
+        service,
+        accessKeyId,
+        secretAccessKey,
+        body = '',
+        headers: extraHeaders = {},
+        timestamp = new Date(),
+    } = options;
+
+    const parsedUrl = new URL(urlStr);
+    const amzDate = timestamp.toISOString().replace(/[:-]/g, '').replace(/\.\d{3}/, '');
+    const dateStamp = amzDate.slice(0, 8);
+
+    const headersToSign: Record<string, string> = {
+        host: parsedUrl.host,
+        'x-amz-date': amzDate,
+    };
+
+    for (const [k, v] of Object.entries(extraHeaders)) {
+        headersToSign[k.toLowerCase()] = v.trim().replace(/\s+/g, ' ');
+    }
+
+    const sortedHeaderKeys = Object.keys(headersToSign).sort();
+    const canonicalHeaders = sortedHeaderKeys.map(k => `${k}:${headersToSign[k]}\n`).join('');
+    const signedHeaders = sortedHeaderKeys.join(';');
+
+    // Canonical URI
+    let canonicalUri = parsedUrl.pathname;
+    if (!canonicalUri) {
+        canonicalUri = '/';
+    } else {
+        canonicalUri = canonicalUri
+            .split('/')
+            .map(segment => encodeRfc3986(segment))
+            .join('/');
+    }
+
+    // Canonical Query String
+    const queryParams: [string, string][] = [];
+    parsedUrl.searchParams.forEach((val, key) => {
+        queryParams.push([encodeRfc3986(key), encodeRfc3986(val)]);
+    });
+    queryParams.sort(([k1, v1], [k2, v2]) => {
+        if (k1 === k2) { return v1.localeCompare(v2); }
+        return k1.localeCompare(k2);
+    });
+    const canonicalQueryString = queryParams.map(([k, v]) => `${k}=${v}`).join('&');
+
+    const payloadHash = sha256Hex(body);
+
+    const canonicalRequest = [
+        method.toUpperCase(),
+        canonicalUri,
+        canonicalQueryString,
+        canonicalHeaders,
+        signedHeaders,
+        payloadHash,
+    ].join('\n');
+
+    const hashedCanonicalRequest = sha256Hex(canonicalRequest);
+    const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+
+    const stringToSign = [
+        'AWS4-HMAC-SHA256',
+        amzDate,
+        credentialScope,
+        hashedCanonicalRequest,
+    ].join('\n');
+
+    const kDate = hmac(`AWS4${secretAccessKey}`, dateStamp);
+    const kRegion = hmac(kDate, region);
+    const kService = hmac(kRegion, service);
+    const kSigning = hmac(kService, 'aws4_request');
+
+    const signature = crypto.createHmac('sha256', kSigning).update(stringToSign, 'utf8').digest('hex');
+    const authorization = `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+
+    const resultHeaders: Record<string, string> = {
+        Host: parsedUrl.host,
+        'X-Amz-Date': amzDate,
+        Authorization: authorization,
+    };
+
+    for (const [k, v] of Object.entries(extraHeaders)) {
+        resultHeaders[k] = v;
+    }
+
+    return {
+        headers: resultHeaders,
+        amzDate,
+        signature,
+        authorization,
+    };
+}

package/src/email/aws/email-receiver-aws.mts

@@ -0,0 +1,107 @@
+/**
+ * AWS SES concrete driver implementation of EmailReceiverBase.
+ * Parses SES notification webhooks (SNS / S3) and evaluates spam/SPF/DKIM/virus verdicts.
+ */
+
+import { parseEmailAddress, sanitizeHeaderValue } from '../email-helpers.mjs';
+import { EmailReceiverBase } from '../email-receiver.mjs';
+import { EmailSpamVerdicts, InboundEmail } from '../email-types.mjs';
+
+export class EmailReceiverAws extends EmailReceiverBase {
+    /**
+     * Parses an incoming AWS SES webhook or SNS notification payload into a normalized InboundEmail object.
+     */
+    async parseInboundPayload(payload: any): Promise<InboundEmail> {
+        let rawData = payload;
+
+        if (typeof rawData === 'string') {
+            try {
+                rawData = JSON.parse(rawData);
+            } catch {
+                throw new Error('Invalid JSON string in AWS inbound payload. (E: 6f7890123456789abcdef6a7b8c9d0e1)');
+            }
+        }
+
+        // Validate SNS SigningCertURL domain if present (prevents SSRF / unauthenticated cert host spoofing)
+        if (rawData && typeof rawData === 'object' && rawData.SigningCertURL) {
+            try {
+                const certUrl = new URL(rawData.SigningCertURL);
+                if (certUrl.protocol !== 'https:' || !certUrl.hostname.endsWith('.amazonaws.com')) {
+                    throw new Error(`Invalid SNS SigningCertURL host: ${rawData.SigningCertURL} (E: a9b8c7d6e5f432109876543210fedcba)`);
+                }
+            } catch (err: any) {
+                if (err?.message?.includes('(E: ')) { throw err; }
+                throw new Error(`Invalid SNS SigningCertURL: ${err?.message || String(err)} (E: b8c7d6e5f432109876543210fedcba9)`);
+            }
+        }
+
+        // If payload is wrapped inside an SNS message: { Type: 'Notification', Message: '{...}' }
+        if (rawData && typeof rawData === 'object' && rawData.Message && typeof rawData.Message === 'string') {
+            try {
+                rawData = JSON.parse(rawData.Message);
+            } catch {
+                // If Message is not JSON, retain outer object
+            }
+        }
+
+        if (!rawData || typeof rawData !== 'object') {
+            throw new Error('Invalid payload structure for AWS SES email parsing. (E: 7890123456789abcdef7a8b9c0d1e2f3)');
+        }
+
+        const mail = rawData.mail || {};
+        const receipt = rawData.receipt || {};
+
+        const messageId = mail.messageId || rawData.messageId || `aws-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const receivedAt = mail.timestamp || receipt.timestamp || new Date().toISOString();
+
+        // Extract From
+        let fromRaw = mail.source || mail.commonHeaders?.from?.[0] || rawData.from || 'unknown@unknown.com';
+        if (Array.isArray(fromRaw)) { fromRaw = fromRaw[0]; }
+        const from = parseEmailAddress(fromRaw);
+
+        // Extract To
+        const toRawList = mail.destination || mail.commonHeaders?.to || rawData.to || [];
+        const toList: string[] = Array.isArray(toRawList) ? toRawList : [toRawList];
+        const to = toList.map(t => parseEmailAddress(t));
+
+        // Extract Cc
+        const ccRawList = mail.commonHeaders?.cc || rawData.cc;
+        const cc = ccRawList ? (Array.isArray(ccRawList) ? ccRawList : [ccRawList]).map(c => parseEmailAddress(c)) : undefined;
+
+        // Subject (sanitized against header injection)
+        const subjectRaw = mail.commonHeaders?.subject || rawData.subject || '(No Subject)';
+        const subject = sanitizeHeaderValue(subjectRaw);
+
+        // Extract Verdicts
+        const spamVerdicts: EmailSpamVerdicts = {
+            spamVerdict: receipt.spamVerdict?.status || rawData.spamVerdict || 'PASS',
+            virusVerdict: receipt.virusVerdict?.status || rawData.virusVerdict || 'PASS',
+            spfVerdict: receipt.spfVerdict?.status || rawData.spfVerdict || 'PASS',
+            dkimVerdict: receipt.dkimVerdict?.status || rawData.dkimVerdict || 'PASS',
+            dmarcVerdict: receipt.dmarcVerdict?.status || rawData.dmarcVerdict || 'PASS',
+        };
+
+        const folder = this.evaluateSpamVerdicts(spamVerdicts);
+
+        const textBody = rawData.textBody || rawData.content || undefined;
+        const htmlBody = rawData.htmlBody || undefined;
+        const rawMime = rawData.rawMime || (typeof rawData.content === 'string' ? rawData.content : undefined);
+
+        const inboundEmail: InboundEmail = {
+            messageId,
+            from,
+            to,
+            cc,
+            subject,
+            textBody,
+            htmlBody,
+            rawMime,
+            receivedAt,
+            spamVerdicts,
+            folder,
+            headers: mail.commonHeaders || rawData.headers,
+        };
+
+        return inboundEmail;
+    }
+}

package/src/email/aws/email-sender-aws.mts

@@ -0,0 +1,130 @@
+/**
+ * AWS SES concrete driver implementation of EmailSenderBase.
+ */
+
+import { DEFAULT_AWS_REGION, DEFAULT_AWS_SERVICE, DEFAULT_AWS_SES_ENDPOINT } from '../email-constants.mjs';
+import { formatEmailAddress } from '../email-helpers.mjs';
+import { EmailSenderBase } from '../email-sender.mjs';
+import { EmailSendResult, OutboundEmail } from '../email-types.mjs';
+import { createAwsSigV4Headers } from './aws-sigv4-helper.mjs';
+
+export interface EmailSenderAwsOptions {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region?: string;
+    endpoint?: string;
+    /** Custom fetch implementation (optional, defaults to globalThis.fetch) */
+    fetchFn?: typeof fetch;
+}
+
+export class EmailSenderAws extends EmailSenderBase {
+    private accessKeyId: string;
+    private secretAccessKey: string;
+    private region: string;
+    private endpoint: string;
+    private fetchFn: typeof fetch;
+
+    constructor(options: EmailSenderAwsOptions) {
+        super();
+        if (!options.accessKeyId || !options.secretAccessKey) {
+            throw new Error('EmailSenderAws requires accessKeyId and secretAccessKey. (E: 5e6f7890123456789abcdef5a6b7c8d9)');
+        }
+        this.accessKeyId = options.accessKeyId;
+        this.secretAccessKey = options.secretAccessKey;
+        this.region = options.region || DEFAULT_AWS_REGION;
+        this.endpoint = options.endpoint || `https://email.${this.region}.amazonaws.com`;
+        this.fetchFn = options.fetchFn || globalThis.fetch;
+    }
+
+    async sendEmail(email: OutboundEmail): Promise<EmailSendResult> {
+        try {
+            this.validateOutboundEmail(email);
+
+            const params = new URLSearchParams();
+            params.append('Action', 'SendEmail');
+            params.append('Version', '2010-12-01');
+            params.append('Source', formatEmailAddress(email.from));
+
+            email.to.forEach((addr, idx) => {
+                params.append(`Destination.ToAddresses.member.${idx + 1}`, formatEmailAddress(addr));
+            });
+
+            if (email.cc && email.cc.length > 0) {
+                email.cc.forEach((addr, idx) => {
+                    params.append(`Destination.CcAddresses.member.${idx + 1}`, formatEmailAddress(addr));
+                });
+            }
+
+            if (email.bcc && email.bcc.length > 0) {
+                email.bcc.forEach((addr, idx) => {
+                    params.append(`Destination.BccAddresses.member.${idx + 1}`, formatEmailAddress(addr));
+                });
+            }
+
+            if (email.replyTo) {
+                params.append('ReplyToAddresses.member.1', formatEmailAddress(email.replyTo));
+            }
+
+            params.append('Message.Subject.Data', email.subject);
+            params.append('Message.Subject.Charset', 'UTF-8');
+
+            if (email.textBody) {
+                params.append('Message.Body.Text.Data', email.textBody);
+                params.append('Message.Body.Text.Charset', 'UTF-8');
+            }
+
+            if (email.htmlBody) {
+                params.append('Message.Body.Html.Data', email.htmlBody);
+                params.append('Message.Body.Html.Charset', 'UTF-8');
+            }
+
+            const bodyString = params.toString();
+            const headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            };
+
+            const sigV4Result = createAwsSigV4Headers({
+                method: 'POST',
+                url: this.endpoint,
+                region: this.region,
+                service: DEFAULT_AWS_SERVICE,
+                accessKeyId: this.accessKeyId,
+                secretAccessKey: this.secretAccessKey,
+                body: bodyString,
+                headers,
+            });
+
+            const response = await this.fetchFn(this.endpoint, {
+                method: 'POST',
+                headers: sigV4Result.headers,
+                body: bodyString,
+            });
+
+            const responseText = await response.text();
+
+            if (response.ok) {
+                // Parse MessageId from XML response: <MessageId>010001...</MessageId>
+                const messageIdMatch = responseText.match(/<MessageId>(.*?)<\/MessageId>/);
+                const messageId = messageIdMatch ? messageIdMatch[1] : undefined;
+                return {
+                    success: true,
+                    messageId,
+                    statusCode: response.status,
+                };
+            } else {
+                const errorMatch = responseText.match(/<Message>(.*?)<\/Message>/);
+                const errorMsg = errorMatch ? errorMatch[1] : responseText;
+                return {
+                    success: false,
+                    error: `AWS SES Error (${response.status}): ${errorMsg}`,
+                    statusCode: response.status,
+                };
+            }
+        } catch (error: any) {
+            return {
+                success: false,
+                error: error?.message || String(error),
+            };
+        }
+    }
+}

package/src/email/aws/index.mts

@@ -0,0 +1,7 @@
+/**
+ * AWS email driver exports.
+ */
+
+export * from './aws-sigv4-helper.mjs';
+export * from './email-sender-aws.mjs';
+export * from './email-receiver-aws.mjs';

package/src/email/email-constants.mts

@@ -0,0 +1,18 @@
+/**
+ * Constants for email infrastructure in node-gib.
+ */
+
+export const DEFAULT_EMAIL_CHARSET = 'UTF-8';
+export const EMAIL_MODE_AWS = 'aws';
+export const EMAIL_MODE_MOCK = 'mock';
+
+export const DEFAULT_AWS_REGION = 'us-east-1';
+export const DEFAULT_AWS_SES_ENDPOINT = 'https://email.us-east-1.amazonaws.com';
+export const DEFAULT_AWS_SERVICE = 'ses';
+
+export const VERDICT_PASS = 'PASS';
+export const VERDICT_FAIL = 'FAIL';
+export const VERDICT_GRAY = 'GRAY';
+
+export const FOLDER_INBOX = 'inbox';
+export const FOLDER_JUNK = 'junk';

package/src/email/email-helpers.mts

@@ -0,0 +1,160 @@
+/**
+ * Helper functions for email parsing, validation, and MIME string formatting.
+ */
+
+import { DEFAULT_EMAIL_CHARSET } from './email-constants.mjs';
+import { EmailAddress, OutboundEmail } from './email-types.mjs';
+
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+/**
+ * Validates whether an email string matches standard email formatting.
+ */
+export function validateEmail(email: string): boolean {
+    if (!email || typeof email !== 'string') { return false; }
+    return EMAIL_REGEX.test(email.trim());
+}
+
+/** Alias for validateEmail for email address format checking. */
+export function validateEmailAddress(email: string): boolean {
+    return validateEmail(email);
+}
+
+
+/**
+ * Sanitizes header values by stripping carriage return (\r) and newline (\n) characters
+ * to prevent MIME header injection.
+ */
+export function sanitizeHeaderValue(val: string): string {
+    if (!val || typeof val !== 'string') { return ''; }
+    return val.replace(/[\r\n]/g, '').trim();
+}
+
+/**
+ * Parses a string or EmailAddress object into a normalized EmailAddress object.
+ * Examples:
+ * - "Alice <alice@example.com>" -> { name: "Alice", address: "alice@example.com" }
+ * - "alice@example.com" -> { address: "alice@example.com" }
+ */
+export function parseEmailAddress(addr: EmailAddress | string): EmailAddress {
+    if (typeof addr === 'object' && addr !== null) {
+        return {
+            address: sanitizeHeaderValue(addr.address).toLowerCase(),
+            name: addr.name ? sanitizeHeaderValue(addr.name) : undefined,
+        };
+    }
+
+    const str = sanitizeHeaderValue(addr || '');
+    const match = str.match(/^(?:"?([^"]*)"?\s+)?<([^>]+)>$/);
+    if (match) {
+        const name = match[1]?.trim();
+        const address = match[2]?.trim().toLowerCase();
+        return {
+            address,
+            name: name || undefined,
+        };
+    }
+
+    return { address: str.toLowerCase() };
+}
+
+/**
+ * Formats an EmailAddress or string into RFC 2822 format (e.g. `"Alice" <alice@example.com>`).
+ */
+export function formatEmailAddress(addr: EmailAddress | string): string {
+    const parsed = parseEmailAddress(addr);
+    if (parsed.name) {
+        return `"${parsed.name}" <${parsed.address}>`;
+    }
+    return parsed.address;
+}
+
+/**
+ * Parses raw MIME headers string or header record into a key-value record with normalized header names.
+ */
+export function parseRawMimeHeaders(raw: string | Record<string, string>): Record<string, string> {
+    if (typeof raw === 'object' && raw !== null) {
+        return { ...raw };
+    }
+
+    const headers: Record<string, string> = {};
+    if (!raw || typeof raw !== 'string') { return headers; }
+
+    // Header block ends at double newline
+    const headerBlock = raw.split(/\r?\n\r?\n/)[0] || raw;
+    // Unfold multi-line headers
+    const unfolded = headerBlock.replace(/\r?\n[ \t]+/g, ' ');
+    const lines = unfolded.split(/\r?\n/);
+
+    for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+            const key = line.slice(0, colonIdx).trim();
+            const value = line.slice(colonIdx + 1).trim();
+            headers[key] = value;
+        }
+    }
+
+    return headers;
+}
+
+/**
+ * Formats an OutboundEmail object into a raw MIME string (RFC 2822).
+ */
+export function formatRawMimeString(email: OutboundEmail, charset: string = DEFAULT_EMAIL_CHARSET): string {
+    const fromStr = formatEmailAddress(email.from);
+    const toStrs = email.to.map(t => formatEmailAddress(t)).join(', ');
+
+    const lines: string[] = [
+        `From: ${fromStr}`,
+        `To: ${toStrs}`,
+    ];
+
+    if (email.cc && email.cc.length > 0) {
+        lines.push(`Cc: ${email.cc.map(c => formatEmailAddress(c)).join(', ')}`);
+    }
+
+    if (email.replyTo) {
+        lines.push(`Reply-To: ${formatEmailAddress(email.replyTo)}`);
+    }
+
+    lines.push(`Subject: ${sanitizeHeaderValue(email.subject)}`);
+
+    if (email.headers) {
+        for (const [key, val] of Object.entries(email.headers)) {
+            lines.push(`${sanitizeHeaderValue(key)}: ${sanitizeHeaderValue(val)}`);
+        }
+    }
+
+    const hasText = Boolean(email.textBody);
+    const hasHtml = Boolean(email.htmlBody);
+
+    if (hasText && hasHtml) {
+        const boundary = `----=_Part_${Date.now()}_${Math.random().toString(36).substring(2)}`;
+        lines.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+        lines.push('');
+        lines.push(`--${boundary}`);
+        lines.push(`Content-Type: text/plain; charset=${charset}`);
+        lines.push('Content-Transfer-Encoding: 7bit');
+        lines.push('');
+        lines.push(email.textBody || '');
+        lines.push(`--${boundary}`);
+        lines.push(`Content-Type: text/html; charset=${charset}`);
+        lines.push('Content-Transfer-Encoding: 7bit');
+        lines.push('');
+        lines.push(email.htmlBody || '');
+        lines.push(`--${boundary}--`);
+    } else if (hasHtml) {
+        lines.push(`Content-Type: text/html; charset=${charset}`);
+        lines.push('Content-Transfer-Encoding: 7bit');
+        lines.push('');
+        lines.push(email.htmlBody || '');
+    } else {
+        lines.push(`Content-Type: text/plain; charset=${charset}`);
+        lines.push('Content-Transfer-Encoding: 7bit');
+        lines.push('');
+        lines.push(email.textBody || '');
+    }
+
+    return lines.join('\r\n');
+}

package/src/email/email-receiver.mts

@@ -0,0 +1,29 @@
+/**
+ * Abstract base class for EmailReceiver drivers.
+ */
+
+import { FOLDER_INBOX, FOLDER_JUNK, VERDICT_FAIL } from './email-constants.mjs';
+import { EmailReceiver, EmailSpamVerdicts, InboundEmail } from './email-types.mjs';
+
+export abstract class EmailReceiverBase implements EmailReceiver {
+    abstract parseInboundPayload(payload: any): Promise<InboundEmail>;
+
+    /**
+     * Evaluates spam/SPF/DKIM/virus verdicts to determine folder classification ("inbox" vs "junk").
+     */
+    evaluateSpamVerdicts(verdicts: EmailSpamVerdicts): 'inbox' | 'junk' {
+        if (!verdicts) { return FOLDER_INBOX as 'inbox'; }
+
+        const { spamVerdict, virusVerdict, spfVerdict, dkimVerdict } = verdicts;
+        if (
+            spamVerdict === VERDICT_FAIL ||
+            virusVerdict === VERDICT_FAIL ||
+            spfVerdict === VERDICT_FAIL ||
+            dkimVerdict === VERDICT_FAIL
+        ) {
+            return FOLDER_JUNK as 'junk';
+        }
+
+        return FOLDER_INBOX as 'inbox';
+    }
+}

package/src/email/email-sender.mts

@@ -0,0 +1,44 @@
+/**
+ * Abstract base class for EmailSender drivers.
+ */
+
+import { parseEmailAddress, validateEmail } from './email-helpers.mjs';
+import { EmailSender, EmailSendResult, OutboundEmail } from './email-types.mjs';
+
+export abstract class EmailSenderBase implements EmailSender {
+    abstract sendEmail(email: OutboundEmail): Promise<EmailSendResult>;
+
+    /**
+     * Validates required fields on an outbound email object.
+     * Throws an error if required fields are missing or invalid.
+     */
+    protected validateOutboundEmail(email: OutboundEmail): void {
+        if (!email) {
+            throw new Error('OutboundEmail is required. (E: 8f4e2a1b9c3d4e5f6a7b8c9d0e1f2a3b)');
+        }
+
+        const fromParsed = parseEmailAddress(email.from);
+        if (!fromParsed.address || !validateEmail(fromParsed.address)) {
+            throw new Error(`Invalid "from" email address: ${fromParsed.address} (E: a1b2c3d4e5f67890123456789abcdef0)`);
+        }
+
+        if (!email.to || !Array.isArray(email.to) || email.to.length === 0) {
+            throw new Error('Outbound email must contain at least one recipient in "to". (E: 1a2b3c4d5e6f7890123456789abcdef1)');
+        }
+
+        for (const recipient of email.to) {
+            const parsed = parseEmailAddress(recipient);
+            if (!parsed.address || !validateEmail(parsed.address)) {
+                throw new Error(`Invalid "to" email address: ${parsed.address} (E: 2b3c4d5e6f7890123456789abcdef2)`);
+            }
+        }
+
+        if (!email.subject || typeof email.subject !== 'string') {
+            throw new Error('Outbound email must contain a "subject" string. (E: 3c4d5e6f7890123456789abcdef3)');
+        }
+
+        if (!email.textBody && !email.htmlBody) {
+            throw new Error('Outbound email must contain either "textBody" or "htmlBody". (E: 4d5e6f7890123456789abcdef4)');
+        }
+    }
+}