@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/classes.ratelimiter.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Configuration options for rate limiter
+ */
+export interface IRateLimitConfig {
+    /** Maximum tokens per period */
+    maxPerPeriod: number;
+    /** Time period in milliseconds */
+    periodMs: number;
+    /** Whether to apply per domain/key (vs globally) */
+    perKey: boolean;
+    /** Initial token count (defaults to max) */
+    initialTokens?: number;
+    /** Grace tokens to allow occasional bursts */
+    burstTokens?: number;
+    /** Apply global limit in addition to per-key limits */
+    useGlobalLimit?: boolean;
+}
+/**
+ * Rate limiter using token bucket algorithm
+ * Provides more sophisticated rate limiting with burst handling
+ */
+export declare class RateLimiter {
+    /** Rate limit configuration */
+    private config;
+    /** Token buckets per key */
+    private buckets;
+    /** Global bucket for non-keyed rate limiting */
+    private globalBucket;
+    /**
+     * Create a new rate limiter
+     * @param config Rate limiter configuration
+     */
+    constructor(config: IRateLimitConfig);
+    /**
+     * Check if a request is allowed under rate limits
+     * @param key Key to check rate limit for (e.g. domain, user, IP)
+     * @param cost Token cost (defaults to 1)
+     * @returns Whether the request is allowed
+     */
+    isAllowed(key?: string, cost?: number): boolean;
+    /**
+     * Check if a bucket has enough tokens and consume them
+     * @param bucket The token bucket to check
+     * @param cost Token cost
+     * @returns Whether tokens were consumed
+     */
+    private checkBucket;
+    /**
+     * Consume tokens for a request (if available)
+     * @param key Key to consume tokens for
+     * @param cost Token cost (defaults to 1)
+     * @returns Whether tokens were consumed
+     */
+    consume(key?: string, cost?: number): boolean;
+    /**
+     * Get the remaining tokens for a key
+     * @param key Key to check
+     * @returns Number of remaining tokens
+     */
+    getRemainingTokens(key?: string): number;
+    /**
+     * Get stats for a specific key
+     * @param key Key to get stats for
+     * @returns Rate limit statistics
+     */
+    getStats(key?: string): {
+        remaining: number;
+        limit: number;
+        resetIn: number;
+        allowed: number;
+        denied: number;
+    };
+    /**
+     * Get or create a token bucket for a key
+     * @param key The rate limit key
+     * @returns Token bucket
+     */
+    private getBucket;
+    /**
+     * Refill tokens in a bucket based on elapsed time
+     * @param bucket Token bucket to refill
+     */
+    private refillBucket;
+    /**
+     * Reset rate limits for a specific key
+     * @param key Key to reset
+     */
+    reset(key?: string): void;
+    /**
+     * Reset all rate limiters
+     */
+    resetAll(): void;
+    /**
+     * Cleanup old buckets to prevent memory leaks
+     * @param maxAge Maximum age in milliseconds
+     */
+    cleanup(maxAge?: number): void;
+}

package/dist_ts/ts/mail/delivery/classes.ratelimiter.js

@@ -0,0 +1,205 @@
+import { logger } from '../../logger.js';
+/**
+ * Rate limiter using token bucket algorithm
+ * Provides more sophisticated rate limiting with burst handling
+ */
+export class RateLimiter {
+    /**
+     * Create a new rate limiter
+     * @param config Rate limiter configuration
+     */
+    constructor(config) {
+        /** Token buckets per key */
+        this.buckets = new Map();
+        // Set defaults
+        this.config = {
+            maxPerPeriod: config.maxPerPeriod,
+            periodMs: config.periodMs,
+            perKey: config.perKey ?? true,
+            initialTokens: config.initialTokens ?? config.maxPerPeriod,
+            burstTokens: config.burstTokens ?? 0,
+            useGlobalLimit: config.useGlobalLimit ?? false
+        };
+        // Initialize global bucket
+        this.globalBucket = {
+            tokens: this.config.initialTokens,
+            lastRefill: Date.now(),
+            allowed: 0,
+            denied: 0
+        };
+        // Log initialization
+        logger.log('info', `Rate limiter initialized: ${this.config.maxPerPeriod} per ${this.config.periodMs}ms${this.config.perKey ? ' per key' : ''}`);
+    }
+    /**
+     * Check if a request is allowed under rate limits
+     * @param key Key to check rate limit for (e.g. domain, user, IP)
+     * @param cost Token cost (defaults to 1)
+     * @returns Whether the request is allowed
+     */
+    isAllowed(key = 'global', cost = 1) {
+        // If using global bucket directly, just check that
+        if (key === 'global' || !this.config.perKey) {
+            return this.checkBucket(this.globalBucket, cost);
+        }
+        // Get the key-specific bucket
+        const bucket = this.getBucket(key);
+        // If we also need to check global limit
+        if (this.config.useGlobalLimit) {
+            // Both key bucket and global bucket must have tokens
+            return this.checkBucket(bucket, cost) && this.checkBucket(this.globalBucket, cost);
+        }
+        else {
+            // Only need to check the key-specific bucket
+            return this.checkBucket(bucket, cost);
+        }
+    }
+    /**
+     * Check if a bucket has enough tokens and consume them
+     * @param bucket The token bucket to check
+     * @param cost Token cost
+     * @returns Whether tokens were consumed
+     */
+    checkBucket(bucket, cost) {
+        // Refill tokens based on elapsed time
+        this.refillBucket(bucket);
+        // Check if we have enough tokens
+        if (bucket.tokens >= cost) {
+            // Use tokens
+            bucket.tokens -= cost;
+            bucket.allowed++;
+            return true;
+        }
+        else {
+            // Rate limit exceeded
+            bucket.denied++;
+            return false;
+        }
+    }
+    /**
+     * Consume tokens for a request (if available)
+     * @param key Key to consume tokens for
+     * @param cost Token cost (defaults to 1)
+     * @returns Whether tokens were consumed
+     */
+    consume(key = 'global', cost = 1) {
+        const isAllowed = this.isAllowed(key, cost);
+        return isAllowed;
+    }
+    /**
+     * Get the remaining tokens for a key
+     * @param key Key to check
+     * @returns Number of remaining tokens
+     */
+    getRemainingTokens(key = 'global') {
+        const bucket = this.getBucket(key);
+        this.refillBucket(bucket);
+        return bucket.tokens;
+    }
+    /**
+     * Get stats for a specific key
+     * @param key Key to get stats for
+     * @returns Rate limit statistics
+     */
+    getStats(key = 'global') {
+        const bucket = this.getBucket(key);
+        this.refillBucket(bucket);
+        // Calculate time until next token
+        const resetIn = bucket.tokens < this.config.maxPerPeriod ?
+            Math.ceil(this.config.periodMs / this.config.maxPerPeriod) :
+            0;
+        return {
+            remaining: bucket.tokens,
+            limit: this.config.maxPerPeriod,
+            resetIn,
+            allowed: bucket.allowed,
+            denied: bucket.denied
+        };
+    }
+    /**
+     * Get or create a token bucket for a key
+     * @param key The rate limit key
+     * @returns Token bucket
+     */
+    getBucket(key) {
+        if (!this.config.perKey || key === 'global') {
+            return this.globalBucket;
+        }
+        if (!this.buckets.has(key)) {
+            // Create new bucket
+            this.buckets.set(key, {
+                tokens: this.config.initialTokens,
+                lastRefill: Date.now(),
+                allowed: 0,
+                denied: 0
+            });
+        }
+        return this.buckets.get(key);
+    }
+    /**
+     * Refill tokens in a bucket based on elapsed time
+     * @param bucket Token bucket to refill
+     */
+    refillBucket(bucket) {
+        const now = Date.now();
+        const elapsedMs = now - bucket.lastRefill;
+        // Calculate how many tokens to add
+        const rate = this.config.maxPerPeriod / this.config.periodMs;
+        const tokensToAdd = elapsedMs * rate;
+        if (tokensToAdd >= 0.1) { // Allow for partial token refills
+            // Add tokens, but don't exceed the normal maximum (without burst)
+            // This ensures burst tokens are only used for bursts and don't refill
+            const normalMax = this.config.maxPerPeriod;
+            bucket.tokens = Math.min(
+            // Don't exceed max + burst
+            this.config.maxPerPeriod + (this.config.burstTokens || 0), 
+            // Don't exceed normal max when refilling
+            Math.min(normalMax, bucket.tokens + tokensToAdd));
+            // Update last refill time
+            bucket.lastRefill = now;
+        }
+    }
+    /**
+     * Reset rate limits for a specific key
+     * @param key Key to reset
+     */
+    reset(key = 'global') {
+        if (key === 'global' || !this.config.perKey) {
+            this.globalBucket.tokens = this.config.initialTokens;
+            this.globalBucket.lastRefill = Date.now();
+        }
+        else if (this.buckets.has(key)) {
+            const bucket = this.buckets.get(key);
+            bucket.tokens = this.config.initialTokens;
+            bucket.lastRefill = Date.now();
+        }
+    }
+    /**
+     * Reset all rate limiters
+     */
+    resetAll() {
+        this.globalBucket.tokens = this.config.initialTokens;
+        this.globalBucket.lastRefill = Date.now();
+        for (const bucket of this.buckets.values()) {
+            bucket.tokens = this.config.initialTokens;
+            bucket.lastRefill = Date.now();
+        }
+    }
+    /**
+     * Cleanup old buckets to prevent memory leaks
+     * @param maxAge Maximum age in milliseconds
+     */
+    cleanup(maxAge = 24 * 60 * 60 * 1000) {
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, bucket] of this.buckets.entries()) {
+            if (now - bucket.lastRefill > maxAge) {
+                this.buckets.delete(key);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            logger.log('debug', `Cleaned up ${removed} stale rate limit buckets`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/delivery/classes.smtp.client.legacy.d.ts

@@ -0,0 +1,275 @@
+import { Email } from '../core/classes.email.js';
+import type { EmailProcessingMode } from './interfaces.js';
+/**
+ * SMTP client connection options
+ */
+export type 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;
+    /**
+     * Command timeout in milliseconds
+     */
+    commandTimeout?: number;
+    /**
+     * TLS options
+     */
+    tls?: {
+        /**
+         * Whether to verify certificates
+         */
+        rejectUnauthorized?: boolean;
+        /**
+         * Minimum TLS version
+         */
+        minVersion?: string;
+        /**
+         * CA certificate path
+         */
+        ca?: string;
+    };
+    /**
+     * Authentication options
+     */
+    auth?: {
+        /**
+         * Authentication user
+         */
+        user: string;
+        /**
+         * Authentication password
+         */
+        pass: string;
+        /**
+         * Authentication method
+         */
+        method?: 'PLAIN' | 'LOGIN' | 'OAUTH2';
+    };
+    /**
+     * Domain name for EHLO
+     */
+    domain?: string;
+    /**
+     * DKIM options for signing outgoing emails
+     */
+    dkim?: {
+        /**
+         * Whether to sign emails with DKIM
+         */
+        enabled: boolean;
+        /**
+         * Domain name for DKIM
+         */
+        domain: string;
+        /**
+         * Selector for DKIM
+         */
+        selector: string;
+        /**
+         * Private key for DKIM signing
+         */
+        privateKey: string;
+        /**
+         * Headers to sign
+         */
+        headers?: string[];
+    };
+};
+/**
+ * SMTP delivery result
+ */
+export type ISmtpDeliveryResult = {
+    /**
+     * Whether the delivery was successful
+     */
+    success: boolean;
+    /**
+     * Message ID if successful
+     */
+    messageId?: string;
+    /**
+     * Error message if failed
+     */
+    error?: string;
+    /**
+     * SMTP response code
+     */
+    responseCode?: string;
+    /**
+     * Recipients successfully delivered to
+     */
+    acceptedRecipients: string[];
+    /**
+     * Recipients rejected during delivery
+     */
+    rejectedRecipients: string[];
+    /**
+     * Server response
+     */
+    response?: string;
+    /**
+     * Timestamp of the delivery attempt
+     */
+    timestamp: number;
+    /**
+     * Whether DKIM signing was applied
+     */
+    dkimSigned?: boolean;
+    /**
+     * Whether this was a TLS secured delivery
+     */
+    secure?: boolean;
+    /**
+     * Whether authentication was used
+     */
+    authenticated?: boolean;
+};
+/**
+ * SMTP client for sending emails to remote mail servers
+ */
+export declare class SmtpClient {
+    private options;
+    private connected;
+    private socket?;
+    private supportedExtensions;
+    /**
+     * Create a new SMTP client instance
+     * @param options SMTP client connection options
+     */
+    constructor(options: ISmtpClientOptions);
+    /**
+     * Connect to the SMTP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Send EHLO command to the server
+     */
+    private sendEhlo;
+    /**
+     * Start TLS negotiation
+     */
+    private startTls;
+    /**
+     * Upgrade socket to TLS
+     * @param socket Original socket
+     */
+    private upgradeTls;
+    /**
+     * Authenticate with the server
+     */
+    private authenticate;
+    /**
+     * Authenticate using PLAIN method
+     * @param user Username
+     * @param pass Password
+     */
+    private authPlain;
+    /**
+     * Authenticate using LOGIN method
+     * @param user Username
+     * @param pass Password
+     */
+    private authLogin;
+    /**
+     * Authenticate using OAuth2 method
+     * @param user Username
+     * @param token OAuth2 token
+     */
+    private authOAuth2;
+    /**
+     * Send an email through the SMTP client
+     * @param email Email to send
+     * @param processingMode Optional processing mode
+     */
+    sendMail(email: Email, processingMode?: EmailProcessingMode): Promise<ISmtpDeliveryResult>;
+    /**
+     * Apply DKIM signature to email
+     * @param email Email to sign
+     */
+    private applyDkimSignature;
+    /**
+     * Format email for SMTP transmission
+     * @param email Email to format
+     */
+    private getFormattedEmail;
+    /**
+     * Get size of email in bytes
+     * @param email Email to measure
+     */
+    private getEmailSize;
+    /**
+     * Send SMTP command and wait for response
+     * @param command SMTP command to send
+     */
+    private commandQueue;
+    private processingCommands;
+    private supportsPipelining;
+    /**
+     * Send an SMTP command and wait for response
+     * @param command SMTP command to send
+     * @param allowPipelining Whether this command can be pipelined
+     */
+    private sendCommand;
+    /**
+     * Process the command queue - either one by one or pipelined if supported
+     */
+    private processCommandQueue;
+    /**
+     * Process the next command in the queue (non-pipelined mode)
+     */
+    private processNextCommand;
+    /**
+     * Process responses for pipelined commands
+     */
+    private processResponses;
+    /**
+     * Read response from the server
+     */
+    private readResponse;
+    /**
+     * Check if the response is complete
+     * @param response Response to check
+     */
+    private isCompleteResponse;
+    /**
+     * Check if the response is an error
+     * @param response Response to check
+     */
+    private isErrorResponse;
+    /**
+     * Create appropriate error from response
+     * @param response Error response
+     * @param code SMTP status code
+     */
+    private createErrorFromResponse;
+    /**
+     * Close the connection to the server
+     */
+    close(): Promise<void>;
+    /**
+     * Checks if the connection is active
+     */
+    isConnected(): boolean;
+    /**
+     * Update SMTP client options
+     * @param options New options
+     */
+    updateOptions(options: Partial<ISmtpClientOptions>): void;
+}