@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/smtpclient/utils/logging.js

@@ -0,0 +1,153 @@
+/**
+ * SMTP Client Logging Utilities
+ * Client-side logging utilities for SMTP operations
+ */
+import { logger } from '../../../../logger.js';
+/**
+ * Log SMTP client connection events
+ */
+export function logConnection(event, options, data) {
+    const logData = {
+        component: 'smtp-client',
+        event,
+        host: options.host,
+        port: options.port,
+        secure: options.secure,
+        ...data
+    };
+    switch (event) {
+        case 'connecting':
+            logger.info('SMTP client connecting', logData);
+            break;
+        case 'connected':
+            logger.info('SMTP client connected', logData);
+            break;
+        case 'disconnected':
+            logger.info('SMTP client disconnected', logData);
+            break;
+        case 'error':
+            logger.error('SMTP client connection error', logData);
+            break;
+    }
+}
+/**
+ * Log SMTP command execution
+ */
+export function logCommand(command, response, options, data) {
+    const logData = {
+        component: 'smtp-client',
+        command,
+        response,
+        host: options?.host,
+        port: options?.port,
+        ...data
+    };
+    if (response && response.code >= 400) {
+        logger.warn('SMTP command failed', logData);
+    }
+    else {
+        logger.debug('SMTP command executed', logData);
+    }
+}
+/**
+ * Log authentication events
+ */
+export function logAuthentication(event, method, options, data) {
+    const logData = {
+        component: 'smtp-client',
+        event: `auth_${event}`,
+        authMethod: method,
+        host: options.host,
+        port: options.port,
+        ...data
+    };
+    switch (event) {
+        case 'start':
+            logger.debug('SMTP authentication started', logData);
+            break;
+        case 'success':
+            logger.info('SMTP authentication successful', logData);
+            break;
+        case 'failure':
+            logger.error('SMTP authentication failed', logData);
+            break;
+    }
+}
+/**
+ * Log TLS/STARTTLS events
+ */
+export function logTLS(event, options, data) {
+    const logData = {
+        component: 'smtp-client',
+        event,
+        host: options.host,
+        port: options.port,
+        ...data
+    };
+    if (event.includes('failure')) {
+        logger.error('SMTP TLS operation failed', logData);
+    }
+    else {
+        logger.info('SMTP TLS operation', logData);
+    }
+}
+/**
+ * Log email sending events
+ */
+export function logEmailSend(event, recipients, options, data) {
+    const logData = {
+        component: 'smtp-client',
+        event: `send_${event}`,
+        recipientCount: recipients.length,
+        recipients: recipients.slice(0, 5), // Only log first 5 recipients for privacy
+        host: options.host,
+        port: options.port,
+        ...data
+    };
+    switch (event) {
+        case 'start':
+            logger.info('SMTP email send started', logData);
+            break;
+        case 'success':
+            logger.info('SMTP email send successful', logData);
+            break;
+        case 'failure':
+            logger.error('SMTP email send failed', logData);
+            break;
+    }
+}
+/**
+ * Log performance metrics
+ */
+export function logPerformance(operation, duration, options, data) {
+    const logData = {
+        component: 'smtp-client',
+        operation,
+        duration,
+        host: options.host,
+        port: options.port,
+        ...data
+    };
+    if (duration > 10000) { // Log slow operations (>10s)
+        logger.warn('SMTP slow operation detected', logData);
+    }
+    else {
+        logger.debug('SMTP operation performance', logData);
+    }
+}
+/**
+ * Log debug information (only when debug is enabled)
+ */
+export function logDebug(message, options, data) {
+    if (!options.debug) {
+        return;
+    }
+    const logData = {
+        component: 'smtp-client-debug',
+        host: options.host,
+        port: options.port,
+        ...data
+    };
+    logger.debug(`[SMTP Client Debug] ${message}`, logData);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/delivery/smtpclient/utils/validation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * SMTP Client Validation Utilities
+ * Input validation functions for SMTP client operations
+ */
+import type { ISmtpClientOptions, ISmtpAuthOptions } from '../interfaces.js';
+/**
+ * Validate email address format
+ * Supports RFC-compliant addresses including empty return paths for bounces
+ */
+export declare function validateEmailAddress(email: string): boolean;
+/**
+ * Validate SMTP client options
+ */
+export declare function validateClientOptions(options: ISmtpClientOptions): string[];
+/**
+ * Validate authentication options
+ */
+export declare function validateAuthOptions(auth: ISmtpAuthOptions): string[];
+/**
+ * Validate hostname format
+ */
+export declare function validateHostname(hostname: string): boolean;
+/**
+ * Validate port number
+ */
+export declare function validatePort(port: number): boolean;
+/**
+ * Sanitize and validate domain name for EHLO
+ */
+export declare function validateAndSanitizeDomain(domain: string): string;
+/**
+ * Validate recipient list
+ */
+export declare function validateRecipients(recipients: string | string[]): string[];
+/**
+ * Validate sender address
+ */
+export declare function validateSender(sender: string): boolean;

package/dist_ts/ts/mail/delivery/smtpclient/utils/validation.js

@@ -0,0 +1,139 @@
+/**
+ * SMTP Client Validation Utilities
+ * Input validation functions for SMTP client operations
+ */
+import { REGEX_PATTERNS } from '../constants.js';
+/**
+ * Validate email address format
+ * Supports RFC-compliant addresses including empty return paths for bounces
+ */
+export function validateEmailAddress(email) {
+    if (typeof email !== 'string') {
+        return false;
+    }
+    const trimmed = email.trim();
+    // Handle empty return path for bounce messages (RFC 5321)
+    if (trimmed === '' || trimmed === '<>') {
+        return true;
+    }
+    // Handle display name formats
+    const angleMatch = trimmed.match(/<([^>]+)>/);
+    if (angleMatch) {
+        return REGEX_PATTERNS.EMAIL_ADDRESS.test(angleMatch[1]);
+    }
+    // Regular email validation
+    return REGEX_PATTERNS.EMAIL_ADDRESS.test(trimmed);
+}
+/**
+ * Validate SMTP client options
+ */
+export function validateClientOptions(options) {
+    const errors = [];
+    // Required fields
+    if (!options.host || typeof options.host !== 'string') {
+        errors.push('Host is required and must be a string');
+    }
+    if (!options.port || typeof options.port !== 'number' || options.port < 1 || options.port > 65535) {
+        errors.push('Port must be a number between 1 and 65535');
+    }
+    // Optional field validation
+    if (options.connectionTimeout !== undefined) {
+        if (typeof options.connectionTimeout !== 'number' || options.connectionTimeout < 1000) {
+            errors.push('Connection timeout must be a number >= 1000ms');
+        }
+    }
+    if (options.socketTimeout !== undefined) {
+        if (typeof options.socketTimeout !== 'number' || options.socketTimeout < 1000) {
+            errors.push('Socket timeout must be a number >= 1000ms');
+        }
+    }
+    if (options.maxConnections !== undefined) {
+        if (typeof options.maxConnections !== 'number' || options.maxConnections < 1) {
+            errors.push('Max connections must be a positive number');
+        }
+    }
+    if (options.maxMessages !== undefined) {
+        if (typeof options.maxMessages !== 'number' || options.maxMessages < 1) {
+            errors.push('Max messages must be a positive number');
+        }
+    }
+    // Validate authentication options
+    if (options.auth) {
+        errors.push(...validateAuthOptions(options.auth));
+    }
+    return errors;
+}
+/**
+ * Validate authentication options
+ */
+export function validateAuthOptions(auth) {
+    const errors = [];
+    if (auth.method && !['PLAIN', 'LOGIN', 'OAUTH2', 'AUTO'].includes(auth.method)) {
+        errors.push('Invalid authentication method');
+    }
+    // For basic auth, require user and pass
+    if ((auth.user || auth.pass) && (!auth.user || !auth.pass)) {
+        errors.push('Both user and pass are required for basic authentication');
+    }
+    // For OAuth2, validate required fields
+    if (auth.oauth2) {
+        const oauth = auth.oauth2;
+        if (!oauth.user || !oauth.clientId || !oauth.clientSecret || !oauth.refreshToken) {
+            errors.push('OAuth2 requires user, clientId, clientSecret, and refreshToken');
+        }
+        if (oauth.user && !validateEmailAddress(oauth.user)) {
+            errors.push('OAuth2 user must be a valid email address');
+        }
+    }
+    return errors;
+}
+/**
+ * Validate hostname format
+ */
+export function validateHostname(hostname) {
+    if (!hostname || typeof hostname !== 'string') {
+        return false;
+    }
+    // Basic hostname validation (allow IP addresses and domain names)
+    const hostnameRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$|^(?:\d{1,3}\.){3}\d{1,3}$|^\[(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\]$/;
+    return hostnameRegex.test(hostname);
+}
+/**
+ * Validate port number
+ */
+export function validatePort(port) {
+    return typeof port === 'number' && port >= 1 && port <= 65535;
+}
+/**
+ * Sanitize and validate domain name for EHLO
+ */
+export function validateAndSanitizeDomain(domain) {
+    if (!domain || typeof domain !== 'string') {
+        return 'localhost';
+    }
+    const sanitized = domain.trim().toLowerCase();
+    if (validateHostname(sanitized)) {
+        return sanitized;
+    }
+    return 'localhost';
+}
+/**
+ * Validate recipient list
+ */
+export function validateRecipients(recipients) {
+    const errors = [];
+    const recipientList = Array.isArray(recipients) ? recipients : [recipients];
+    for (const recipient of recipientList) {
+        if (!validateEmailAddress(recipient)) {
+            errors.push(`Invalid email address: ${recipient}`);
+        }
+    }
+    return errors;
+}
+/**
+ * Validate sender address
+ */
+export function validateSender(sender) {
+    return validateEmailAddress(sender);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/delivery/smtpserver/certificate-utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Certificate Utilities for SMTP Server
+ * Provides utilities for managing TLS certificates
+ */
+import * as tls from 'tls';
+/**
+ * Certificate data
+ */
+export interface ICertificateData {
+    key: Buffer;
+    cert: Buffer;
+    ca?: Buffer;
+}
+/**
+ * Load certificates from PEM format strings
+ * @param options - Certificate options
+ * @returns Certificate data with Buffer format
+ */
+export declare function loadCertificatesFromString(options: {
+    key: string | Buffer;
+    cert: string | Buffer;
+    ca?: string | Buffer;
+}): ICertificateData;
+/**
+ * Load certificates from files
+ * @param options - Certificate file paths
+ * @returns Certificate data with Buffer format
+ */
+export declare function loadCertificatesFromFiles(options: {
+    keyPath: string;
+    certPath: string;
+    caPath?: string;
+}): ICertificateData;
+/**
+ * Generate self-signed certificates for testing
+ * @returns Certificate data with Buffer format
+ */
+export declare function generateSelfSignedCertificates(): ICertificateData;
+/**
+ * Create TLS options for secure server or STARTTLS
+ * @param certificates - Certificate data
+ * @param isServer - Whether this is for server (true) or client (false)
+ * @returns TLS options
+ */
+export declare function createTlsOptions(certificates: ICertificateData, isServer?: boolean): tls.TlsOptions;