@push.rocks/smartmta 5.1.2 → 5.2.0

package/dist_ts/mail/routing/classes.unified.email.server.d.ts

@@ -0,0 +1,241 @@
+import { EventEmitter } from 'events';
+import { DKIMCreator } from '../security/classes.dkimcreator.js';
+import type { IEmailRoute, IEmailDomainConfig } from './interfaces.js';
+import { Email } from '../core/classes.email.js';
+import { DomainRegistry } from './classes.domain.registry.js';
+import { BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
+import type { ISmtpSendResult } from '../../security/classes.rustsecuritybridge.js';
+import { MultiModeDeliverySystem } from '../delivery/classes.delivery.system.js';
+import { UnifiedDeliveryQueue } from '../delivery/classes.delivery.queue.js';
+import { UnifiedRateLimiter, type IHierarchicalRateLimits } from '../delivery/classes.unified.rate.limiter.js';
+import type { EmailProcessingMode, ISmtpSession as IBaseSmtpSession } from '../delivery/interfaces.js';
+/** External DcRouter interface shape used by UnifiedEmailServer */
+interface DcRouter {
+    storageManager: any;
+    dnsServer?: any;
+    options?: any;
+}
+/**
+ * Extended SMTP session interface with route information
+ */
+export interface IExtendedSmtpSession extends ISmtpSession {
+    /**
+     * Matched route for this session
+     */
+    matchedRoute?: IEmailRoute;
+}
+/**
+ * Options for the unified email server
+ */
+export interface IUnifiedEmailServerOptions {
+    ports: number[];
+    hostname: string;
+    domains: IEmailDomainConfig[];
+    banner?: string;
+    debug?: boolean;
+    useSocketHandler?: boolean;
+    auth?: {
+        required?: boolean;
+        methods?: ('PLAIN' | 'LOGIN' | 'OAUTH2')[];
+        users?: Array<{
+            username: string;
+            password: string;
+        }>;
+    };
+    tls?: {
+        certPath?: string;
+        keyPath?: string;
+        caPath?: string;
+        minVersion?: string;
+        ciphers?: string;
+    };
+    maxMessageSize?: number;
+    maxClients?: number;
+    maxConnections?: number;
+    connectionTimeout?: number;
+    socketTimeout?: number;
+    routes: IEmailRoute[];
+    defaults?: {
+        dnsMode?: 'forward' | 'internal-dns' | 'external-dns';
+        dkim?: IEmailDomainConfig['dkim'];
+        rateLimits?: IEmailDomainConfig['rateLimits'];
+    };
+    outbound?: {
+        maxConnections?: number;
+        connectionTimeout?: number;
+        socketTimeout?: number;
+        retryAttempts?: number;
+        defaultFrom?: string;
+    };
+    rateLimits?: IHierarchicalRateLimits;
+}
+/**
+ * Extended SMTP session interface for UnifiedEmailServer
+ */
+export interface ISmtpSession extends IBaseSmtpSession {
+    /**
+     * User information if authenticated
+     */
+    user?: {
+        username: string;
+        [key: string]: any;
+    };
+    /**
+     * Matched route for this session
+     */
+    matchedRoute?: IEmailRoute;
+}
+/**
+ * Authentication data for SMTP
+ */
+import type { ISmtpAuth } from '../delivery/interfaces.js';
+export type IAuthData = ISmtpAuth;
+/**
+ * Server statistics
+ */
+export interface IServerStats {
+    startTime: Date;
+    connections: {
+        current: number;
+        total: number;
+    };
+    messages: {
+        processed: number;
+        delivered: number;
+        failed: number;
+    };
+    processingTime: {
+        avg: number;
+        max: number;
+        min: number;
+    };
+}
+/**
+ * Unified email server that handles all email traffic with pattern-based routing
+ */
+export declare class UnifiedEmailServer extends EventEmitter {
+    private dcRouter;
+    private options;
+    private emailRouter;
+    domainRegistry: DomainRegistry;
+    private servers;
+    private stats;
+    dkimCreator: DKIMCreator;
+    private rustBridge;
+    private bounceManager;
+    deliveryQueue: UnifiedDeliveryQueue;
+    deliverySystem: MultiModeDeliverySystem;
+    private rateLimiter;
+    private actionExecutor;
+    private dkimManager;
+    constructor(dcRouter: DcRouter, options: IUnifiedEmailServerOptions);
+    /**
+     * Send an outbound email via the Rust SMTP client.
+     * Uses connection pooling in the Rust binary for efficiency.
+     */
+    sendOutboundEmail(host: string, port: number, email: Email, options?: {
+        auth?: {
+            user: string;
+            pass: string;
+        };
+        dkimDomain?: string;
+        dkimSelector?: string;
+        tlsOpportunistic?: boolean;
+    }): Promise<ISmtpSendResult>;
+    /**
+     * Start the unified email server
+     */
+    start(): Promise<void>;
+    private startDeliveryPipeline;
+    private startRustBridge;
+    private initializeDkimAndDns;
+    private registerBridgeEventHandlers;
+    private startSmtpServer;
+    /**
+     * Stop the unified email server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle an emailReceived event from the Rust SMTP server.
+     */
+    private handleRustEmailReceived;
+    /**
+     * Handle an authRequest event from the Rust SMTP server.
+     */
+    private handleRustAuthRequest;
+    /**
+     * Handle a SCRAM credential request from the Rust SMTP server.
+     * Computes SCRAM-SHA-256 credentials from the stored password for the given user.
+     */
+    private handleScramCredentialRequest;
+    /**
+     * Verify inbound email security (DKIM/SPF/DMARC) using pre-computed Rust results
+     * or falling back to IPC call if no pre-computed results are available.
+     */
+    private verifyInboundSecurity;
+    /**
+     * Process email based on routing rules
+     */
+    processEmailByMode(emailData: Email | Buffer, session: IExtendedSmtpSession): Promise<Email>;
+    /**
+     * Apply per-domain rate limits from domain configurations
+     */
+    private applyDomainRateLimits;
+    /**
+     * Generate SmartProxy routes for email ports
+     */
+    generateProxyRoutes(portMapping?: Record<number, number>): any[];
+    /**
+     * Update server configuration
+     */
+    updateOptions(options: Partial<IUnifiedEmailServerOptions>): void;
+    /**
+     * Update email routes
+     */
+    updateEmailRoutes(routes: IEmailRoute[]): void;
+    /**
+     * Get server statistics
+     */
+    getStats(): IServerStats;
+    /**
+     * Get domain registry
+     */
+    getDomainRegistry(): DomainRegistry;
+    /**
+     * Send an email through the delivery system
+     */
+    sendEmail(email: Email, mode?: EmailProcessingMode, route?: IEmailRoute, options?: {
+        skipSuppressionCheck?: boolean;
+        ipAddress?: string;
+        isTransactional?: boolean;
+    }): Promise<string>;
+    processBounceNotification(bounceEmail: Email): Promise<boolean>;
+    processSmtpFailure(recipient: string, smtpResponse: string, options?: {
+        sender?: string;
+        originalEmailId?: string;
+        statusCode?: string;
+        headers?: Record<string, string>;
+    }): Promise<boolean>;
+    isEmailSuppressed(email: string): boolean;
+    getSuppressionInfo(email: string): {
+        reason: string;
+        timestamp: number;
+        expiresAt?: number;
+    } | null;
+    getBounceHistory(email: string): {
+        lastBounce: number;
+        count: number;
+        type: BounceType;
+        category: BounceCategory;
+    } | null;
+    getSuppressionList(): string[];
+    getHardBouncedAddresses(): string[];
+    addToSuppressionList(email: string, reason: string, expiresAt?: number): void;
+    removeFromSuppressionList(email: string): void;
+    recordBounce(domain: string, receivingDomain: string, bounceType: 'hard' | 'soft', reason: string): void;
+    /**
+     * Get the rate limiter instance
+     */
+    getRateLimiter(): UnifiedRateLimiter;
+}
+export {};