@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/smtpclient/interfaces.d.ts

@@ -0,0 +1,183 @@
+/**
+ * SMTP Client Interfaces and Types
+ * All interface definitions for the modular SMTP client
+ */
+import type * as tls from 'node:tls';
+import type * as net from 'node:net';
+/**
+ * SMTP client connection options
+ */
+export interface ISmtpClientOptions {
+    /** Hostname of the SMTP server */
+    host: string;
+    /** Port to connect to */
+    port: number;
+    /** Whether to use TLS for the connection */
+    secure?: boolean;
+    /** Connection timeout in milliseconds */
+    connectionTimeout?: number;
+    /** Socket timeout in milliseconds */
+    socketTimeout?: number;
+    /** Domain name for EHLO command */
+    domain?: string;
+    /** Authentication options */
+    auth?: ISmtpAuthOptions;
+    /** TLS options */
+    tls?: tls.ConnectionOptions;
+    /** Maximum number of connections in pool */
+    pool?: boolean;
+    maxConnections?: number;
+    maxMessages?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Proxy settings */
+    proxy?: string;
+}
+/**
+ * Authentication options for SMTP
+ */
+export interface ISmtpAuthOptions {
+    /** Username */
+    user?: string;
+    /** Password */
+    pass?: string;
+    /** OAuth2 settings */
+    oauth2?: IOAuth2Options;
+    /** Authentication method preference */
+    method?: 'PLAIN' | 'LOGIN' | 'OAUTH2' | 'AUTO';
+}
+/**
+ * OAuth2 authentication options
+ */
+export interface IOAuth2Options {
+    /** OAuth2 user identifier */
+    user: string;
+    /** OAuth2 client ID */
+    clientId: string;
+    /** OAuth2 client secret */
+    clientSecret: string;
+    /** OAuth2 refresh token */
+    refreshToken: string;
+    /** OAuth2 access token */
+    accessToken?: string;
+    /** Token expiry time */
+    expires?: number;
+}
+/**
+ * Result of an email send operation
+ */
+export interface ISmtpSendResult {
+    /** Whether the send was successful */
+    success: boolean;
+    /** Message ID from server */
+    messageId?: string;
+    /** List of accepted recipients */
+    acceptedRecipients: string[];
+    /** List of rejected recipients */
+    rejectedRecipients: string[];
+    /** Error information if failed */
+    error?: Error;
+    /** Server response */
+    response?: string;
+    /** Envelope information */
+    envelope?: ISmtpEnvelope;
+}
+/**
+ * SMTP envelope information
+ */
+export interface ISmtpEnvelope {
+    /** Sender address */
+    from: string;
+    /** Recipient addresses */
+    to: string[];
+}
+/**
+ * Connection pool status
+ */
+export interface IConnectionPoolStatus {
+    /** Total connections in pool */
+    total: number;
+    /** Active connections */
+    active: number;
+    /** Idle connections */
+    idle: number;
+    /** Pending connection requests */
+    pending: number;
+}
+/**
+ * SMTP command response
+ */
+export interface ISmtpResponse {
+    /** Response code */
+    code: number;
+    /** Response message */
+    message: string;
+    /** Enhanced status code */
+    enhancedCode?: string;
+    /** Raw response */
+    raw: string;
+}
+/**
+ * Connection state
+ */
+export declare enum ConnectionState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    AUTHENTICATED = "authenticated",
+    READY = "ready",
+    BUSY = "busy",
+    CLOSING = "closing",
+    ERROR = "error"
+}
+/**
+ * SMTP capabilities
+ */
+export interface ISmtpCapabilities {
+    /** Supported extensions */
+    extensions: Set<string>;
+    /** Maximum message size */
+    maxSize?: number;
+    /** Supported authentication methods */
+    authMethods: Set<string>;
+    /** Support for pipelining */
+    pipelining: boolean;
+    /** Support for STARTTLS */
+    starttls: boolean;
+    /** Support for 8BITMIME */
+    eightBitMime: boolean;
+}
+/**
+ * Internal connection interface
+ */
+export interface ISmtpConnection {
+    /** Socket connection */
+    socket: net.Socket | tls.TLSSocket;
+    /** Connection state */
+    state: ConnectionState;
+    /** Server capabilities */
+    capabilities?: ISmtpCapabilities;
+    /** Connection options */
+    options: ISmtpClientOptions;
+    /** Whether connection is secure */
+    secure: boolean;
+    /** Connection creation time */
+    createdAt: Date;
+    /** Last activity time */
+    lastActivity: Date;
+    /** Number of messages sent */
+    messageCount: number;
+}
+/**
+ * Error context for detailed error reporting
+ */
+export interface ISmtpErrorContext {
+    /** Command that caused the error */
+    command?: string;
+    /** Server response */
+    response?: ISmtpResponse;
+    /** Connection state */
+    connectionState?: ConnectionState;
+    /** Additional context data */
+    data?: Record<string, any>;
+}

package/dist_ts/ts/mail/delivery/smtpclient/interfaces.js

@@ -0,0 +1,19 @@
+/**
+ * SMTP Client Interfaces and Types
+ * All interface definitions for the modular SMTP client
+ */
+/**
+ * Connection state
+ */
+export var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState["DISCONNECTED"] = "disconnected";
+    ConnectionState["CONNECTING"] = "connecting";
+    ConnectionState["CONNECTED"] = "connected";
+    ConnectionState["AUTHENTICATED"] = "authenticated";
+    ConnectionState["READY"] = "ready";
+    ConnectionState["BUSY"] = "busy";
+    ConnectionState["CLOSING"] = "closing";
+    ConnectionState["ERROR"] = "error";
+})(ConnectionState || (ConnectionState = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3RzL21haWwvZGVsaXZlcnkvc210cGNsaWVudC9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQTZKSDs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLGVBU1g7QUFURCxXQUFZLGVBQWU7SUFDekIsZ0RBQTZCLENBQUE7SUFDN0IsNENBQXlCLENBQUE7SUFDekIsMENBQXVCLENBQUE7SUFDdkIsa0RBQStCLENBQUE7SUFDL0Isa0NBQWUsQ0FBQTtJQUNmLGdDQUFhLENBQUE7SUFDYixzQ0FBbUIsQ0FBQTtJQUNuQixrQ0FBZSxDQUFBO0FBQ2pCLENBQUMsRUFUVyxlQUFlLEtBQWYsZUFBZSxRQVMxQiJ9

package/dist_ts/ts/mail/delivery/smtpclient/smtp-client.d.ts

@@ -0,0 +1,58 @@
+/**
+ * SMTP Client Core Implementation
+ * Main client class with delegation to handlers
+ */
+import { EventEmitter } from 'node:events';
+import type { Email } from '../../core/classes.email.js';
+import type { ISmtpClientOptions, ISmtpSendResult, IConnectionPoolStatus } from './interfaces.js';
+import type { ConnectionManager } from './connection-manager.js';
+import type { CommandHandler } from './command-handler.js';
+import type { AuthHandler } from './auth-handler.js';
+import type { TlsHandler } from './tls-handler.js';
+import type { SmtpErrorHandler } from './error-handler.js';
+interface ISmtpClientDependencies {
+    options: ISmtpClientOptions;
+    connectionManager: ConnectionManager;
+    commandHandler: CommandHandler;
+    authHandler: AuthHandler;
+    tlsHandler: TlsHandler;
+    errorHandler: SmtpErrorHandler;
+}
+export declare class SmtpClient extends EventEmitter {
+    private options;
+    private connectionManager;
+    private commandHandler;
+    private authHandler;
+    private tlsHandler;
+    private errorHandler;
+    private isShuttingDown;
+    constructor(dependencies: ISmtpClientDependencies);
+    /**
+     * Send an email
+     */
+    sendMail(email: Email): Promise<ISmtpSendResult>;
+    /**
+     * Test connection to SMTP server
+     */
+    verify(): Promise<boolean>;
+    /**
+     * Check if client is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get connection pool status
+     */
+    getPoolStatus(): IConnectionPoolStatus;
+    /**
+     * Update client options
+     */
+    updateOptions(newOptions: Partial<ISmtpClientOptions>): void;
+    /**
+     * Close all connections and shutdown client
+     */
+    close(): Promise<void>;
+    private formatEmailData;
+    private extractMessageId;
+    private setupEventForwarding;
+}
+export {};

package/dist_ts/ts/mail/delivery/smtpclient/smtp-client.js

@@ -0,0 +1,279 @@
+/**
+ * SMTP Client Core Implementation
+ * Main client class with delegation to handlers
+ */
+import { EventEmitter } from 'node:events';
+import { CONNECTION_STATES, SmtpErrorType } from './constants.js';
+import { validateSender, validateRecipients } from './utils/validation.js';
+import { logEmailSend, logPerformance, logDebug } from './utils/logging.js';
+export class SmtpClient extends EventEmitter {
+    constructor(dependencies) {
+        super();
+        this.isShuttingDown = false;
+        this.options = dependencies.options;
+        this.connectionManager = dependencies.connectionManager;
+        this.commandHandler = dependencies.commandHandler;
+        this.authHandler = dependencies.authHandler;
+        this.tlsHandler = dependencies.tlsHandler;
+        this.errorHandler = dependencies.errorHandler;
+        this.setupEventForwarding();
+    }
+    /**
+     * Send an email
+     */
+    async sendMail(email) {
+        const startTime = Date.now();
+        // Extract clean email addresses without display names for SMTP operations
+        const fromAddress = email.getFromAddress();
+        const recipients = email.getToAddresses();
+        const ccRecipients = email.getCcAddresses();
+        const bccRecipients = email.getBccAddresses();
+        // Combine all recipients for SMTP operations
+        const allRecipients = [...recipients, ...ccRecipients, ...bccRecipients];
+        // Validate email addresses
+        if (!validateSender(fromAddress)) {
+            throw new Error(`Invalid sender address: ${fromAddress}`);
+        }
+        const recipientErrors = validateRecipients(allRecipients);
+        if (recipientErrors.length > 0) {
+            throw new Error(`Invalid recipients: ${recipientErrors.join(', ')}`);
+        }
+        logEmailSend('start', allRecipients, this.options);
+        let connection = null;
+        const result = {
+            success: false,
+            acceptedRecipients: [],
+            rejectedRecipients: [],
+            envelope: {
+                from: fromAddress,
+                to: allRecipients
+            }
+        };
+        try {
+            // Get connection
+            connection = await this.connectionManager.getConnection();
+            connection.state = CONNECTION_STATES.BUSY;
+            // Wait for greeting if new connection
+            if (!connection.capabilities) {
+                await this.commandHandler.waitForGreeting(connection);
+            }
+            // Perform EHLO
+            await this.commandHandler.sendEhlo(connection, this.options.domain);
+            // Upgrade to TLS if needed
+            if (this.tlsHandler.shouldUseTLS(connection)) {
+                await this.tlsHandler.upgradeToTLS(connection);
+                // Re-send EHLO after TLS upgrade
+                await this.commandHandler.sendEhlo(connection, this.options.domain);
+            }
+            // Authenticate if needed
+            if (this.options.auth) {
+                await this.authHandler.authenticate(connection);
+            }
+            // Send MAIL FROM
+            const mailFromResponse = await this.commandHandler.sendMailFrom(connection, fromAddress);
+            if (mailFromResponse.code >= 400) {
+                throw new Error(`MAIL FROM failed: ${mailFromResponse.message}`);
+            }
+            // Send RCPT TO for each recipient (includes TO, CC, and BCC)
+            for (const recipient of allRecipients) {
+                try {
+                    const rcptResponse = await this.commandHandler.sendRcptTo(connection, recipient);
+                    if (rcptResponse.code >= 400) {
+                        result.rejectedRecipients.push(recipient);
+                        logDebug(`Recipient rejected: ${recipient}`, this.options, { response: rcptResponse });
+                    }
+                    else {
+                        result.acceptedRecipients.push(recipient);
+                    }
+                }
+                catch (error) {
+                    result.rejectedRecipients.push(recipient);
+                    logDebug(`Recipient error: ${recipient}`, this.options, { error });
+                }
+            }
+            // Check if we have any accepted recipients
+            if (result.acceptedRecipients.length === 0) {
+                throw new Error('All recipients were rejected');
+            }
+            // Send DATA command
+            const dataResponse = await this.commandHandler.sendData(connection);
+            if (dataResponse.code !== 354) {
+                throw new Error(`DATA command failed: ${dataResponse.message}`);
+            }
+            // Send email content
+            const emailData = await this.formatEmailData(email);
+            const sendResponse = await this.commandHandler.sendDataContent(connection, emailData);
+            if (sendResponse.code >= 400) {
+                throw new Error(`Email data rejected: ${sendResponse.message}`);
+            }
+            // Success
+            result.success = true;
+            result.messageId = this.extractMessageId(sendResponse.message);
+            result.response = sendResponse.message;
+            connection.messageCount++;
+            logEmailSend('success', recipients, this.options, {
+                messageId: result.messageId,
+                duration: Date.now() - startTime
+            });
+        }
+        catch (error) {
+            result.success = false;
+            result.error = error instanceof Error ? error : new Error(String(error));
+            // Classify error and determine if we should retry
+            const errorType = this.errorHandler.classifyError(result.error);
+            result.error = this.errorHandler.createError(result.error.message, errorType, { command: 'SEND_MAIL' }, result.error);
+            logEmailSend('failure', recipients, this.options, {
+                error: result.error,
+                duration: Date.now() - startTime
+            });
+        }
+        finally {
+            // Release connection
+            if (connection) {
+                connection.state = CONNECTION_STATES.READY;
+                this.connectionManager.updateActivity(connection);
+                this.connectionManager.releaseConnection(connection);
+            }
+            logPerformance('sendMail', Date.now() - startTime, this.options);
+        }
+        return result;
+    }
+    /**
+     * Test connection to SMTP server
+     */
+    async verify() {
+        let connection = null;
+        try {
+            connection = await this.connectionManager.createConnection();
+            await this.commandHandler.waitForGreeting(connection);
+            await this.commandHandler.sendEhlo(connection, this.options.domain);
+            if (this.tlsHandler.shouldUseTLS(connection)) {
+                await this.tlsHandler.upgradeToTLS(connection);
+                await this.commandHandler.sendEhlo(connection, this.options.domain);
+            }
+            if (this.options.auth) {
+                await this.authHandler.authenticate(connection);
+            }
+            await this.commandHandler.sendQuit(connection);
+            return true;
+        }
+        catch (error) {
+            logDebug('Connection verification failed', this.options, { error });
+            return false;
+        }
+        finally {
+            if (connection) {
+                this.connectionManager.closeConnection(connection);
+            }
+        }
+    }
+    /**
+     * Check if client is connected
+     */
+    isConnected() {
+        const status = this.connectionManager.getPoolStatus();
+        return status.total > 0;
+    }
+    /**
+     * Get connection pool status
+     */
+    getPoolStatus() {
+        return this.connectionManager.getPoolStatus();
+    }
+    /**
+     * Update client options
+     */
+    updateOptions(newOptions) {
+        this.options = { ...this.options, ...newOptions };
+        logDebug('Client options updated', this.options);
+    }
+    /**
+     * Close all connections and shutdown client
+     */
+    async close() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        this.isShuttingDown = true;
+        logDebug('Shutting down SMTP client', this.options);
+        try {
+            this.connectionManager.closeAllConnections();
+            this.emit('close');
+        }
+        catch (error) {
+            logDebug('Error during client shutdown', this.options, { error });
+        }
+    }
+    async formatEmailData(email) {
+        // Convert Email object to raw SMTP data
+        const headers = [];
+        // Required headers
+        headers.push(`From: ${email.from}`);
+        headers.push(`To: ${Array.isArray(email.to) ? email.to.join(', ') : email.to}`);
+        headers.push(`Subject: ${email.subject || ''}`);
+        headers.push(`Date: ${new Date().toUTCString()}`);
+        headers.push(`Message-ID: <${Date.now()}.${Math.random().toString(36)}@${this.options.host}>`);
+        // Optional headers
+        if (email.cc) {
+            const cc = Array.isArray(email.cc) ? email.cc.join(', ') : email.cc;
+            headers.push(`Cc: ${cc}`);
+        }
+        if (email.bcc) {
+            const bcc = Array.isArray(email.bcc) ? email.bcc.join(', ') : email.bcc;
+            headers.push(`Bcc: ${bcc}`);
+        }
+        // Content headers
+        if (email.html && email.text) {
+            // Multipart message
+            const boundary = `boundary_${Date.now()}_${Math.random().toString(36)}`;
+            headers.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+            headers.push('MIME-Version: 1.0');
+            const body = [
+                `--${boundary}`,
+                'Content-Type: text/plain; charset=utf-8',
+                'Content-Transfer-Encoding: quoted-printable',
+                '',
+                email.text,
+                '',
+                `--${boundary}`,
+                'Content-Type: text/html; charset=utf-8',
+                'Content-Transfer-Encoding: quoted-printable',
+                '',
+                email.html,
+                '',
+                `--${boundary}--`
+            ].join('\r\n');
+            return headers.join('\r\n') + '\r\n\r\n' + body;
+        }
+        else if (email.html) {
+            headers.push('Content-Type: text/html; charset=utf-8');
+            headers.push('MIME-Version: 1.0');
+            return headers.join('\r\n') + '\r\n\r\n' + email.html;
+        }
+        else {
+            headers.push('Content-Type: text/plain; charset=utf-8');
+            headers.push('MIME-Version: 1.0');
+            return headers.join('\r\n') + '\r\n\r\n' + (email.text || '');
+        }
+    }
+    extractMessageId(response) {
+        // Try to extract message ID from server response
+        const match = response.match(/queued as ([^\s]+)/i) ||
+            response.match(/id=([^\s]+)/i) ||
+            response.match(/Message-ID: <([^>]+)>/i);
+        return match ? match[1] : undefined;
+    }
+    setupEventForwarding() {
+        // Forward events from connection manager
+        this.connectionManager.on('connection', (connection) => {
+            this.emit('connection', connection);
+        });
+        this.connectionManager.on('disconnect', (connection) => {
+            this.emit('disconnect', connection);
+        });
+        this.connectionManager.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smtp-client.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpclient/smtp-client.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpclient/tls-handler.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SMTP Client TLS Handler
+ * TLS and STARTTLS client functionality
+ */
+import * as tls from 'node:tls';
+import type { ISmtpConnection, ISmtpClientOptions } from './interfaces.js';
+import type { CommandHandler } from './command-handler.js';
+export declare class TlsHandler {
+    private options;
+    private commandHandler;
+    constructor(options: ISmtpClientOptions, commandHandler: CommandHandler);
+    /**
+     * Upgrade connection to TLS using STARTTLS
+     */
+    upgradeToTLS(connection: ISmtpConnection): Promise<void>;
+    /**
+     * Create a direct TLS connection
+     */
+    createTLSConnection(host: string, port: number): Promise<tls.TLSSocket>;
+    /**
+     * Validate TLS certificate
+     */
+    validateCertificate(socket: tls.TLSSocket): boolean;
+    /**
+     * Get TLS connection information
+     */
+    getTLSInfo(socket: tls.TLSSocket): any;
+    /**
+     * Check if TLS upgrade is required or recommended
+     */
+    shouldUseTLS(connection: ISmtpConnection): boolean;
+    private performTLSUpgrade;
+}