@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/errors/reputation.errors.js

@@ -0,0 +1,292 @@
+import { PlatformError, OperationError, ResourceError } from './base.errors.js';
+import { REPUTATION_CHECK_ERROR, REPUTATION_DATA_ERROR, REPUTATION_BLOCKLIST_ERROR, REPUTATION_UPDATE_ERROR, WARMUP_ALLOCATION_ERROR, WARMUP_LIMIT_EXCEEDED, WARMUP_SCHEDULE_ERROR } from './error.codes.js';
+/**
+ * Base class for reputation-related errors
+ */
+export class ReputationError extends OperationError {
+    /**
+     * Creates a new reputation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, context);
+    }
+}
+/**
+ * Error class for reputation check errors
+ */
+export class ReputationCheckError extends ReputationError {
+    /**
+     * Creates a new reputation check error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, REPUTATION_CHECK_ERROR, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+    /**
+     * Creates an instance for an IP reputation check error
+     *
+     * @param ip IP address
+     * @param provider Reputation provider
+     * @param originalError Original error
+     * @param context Additional context
+     */
+    static ipCheckFailed(ip, provider, originalError, context = {}) {
+        const errorMsg = originalError ? `: ${originalError.message}` : '';
+        return new ReputationCheckError(`Failed to check reputation for IP ${ip} with provider ${provider}${errorMsg}`, {
+            ...context,
+            data: {
+                ...context.data,
+                ip,
+                provider,
+                originalError: originalError ? {
+                    message: originalError.message,
+                    stack: originalError.stack
+                } : undefined
+            }
+        });
+    }
+    /**
+     * Creates an instance for a domain reputation check error
+     *
+     * @param domain Domain
+     * @param provider Reputation provider
+     * @param originalError Original error
+     * @param context Additional context
+     */
+    static domainCheckFailed(domain, provider, originalError, context = {}) {
+        const errorMsg = originalError ? `: ${originalError.message}` : '';
+        return new ReputationCheckError(`Failed to check reputation for domain ${domain} with provider ${provider}${errorMsg}`, {
+            ...context,
+            data: {
+                ...context.data,
+                domain,
+                provider,
+                originalError: originalError ? {
+                    message: originalError.message,
+                    stack: originalError.stack
+                } : undefined
+            }
+        });
+    }
+}
+/**
+ * Error class for reputation data errors
+ */
+export class ReputationDataError extends ReputationError {
+    /**
+     * Creates a new reputation data error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, REPUTATION_DATA_ERROR, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+    /**
+     * Creates an instance for a data access error
+     *
+     * @param entity Entity type (domain, ip)
+     * @param entityId Entity identifier
+     * @param operation Operation that failed (read, write, update)
+     * @param originalError Original error
+     * @param context Additional context
+     */
+    static dataAccessFailed(entity, entityId, operation, originalError, context = {}) {
+        const errorMsg = originalError ? `: ${originalError.message}` : '';
+        return new ReputationDataError(`Failed to ${operation} reputation data for ${entity} ${entityId}${errorMsg}`, {
+            ...context,
+            data: {
+                ...context.data,
+                entity,
+                entityId,
+                operation,
+                originalError: originalError ? {
+                    message: originalError.message,
+                    stack: originalError.stack
+                } : undefined
+            }
+        });
+    }
+}
+/**
+ * Error class for blocklist-related errors
+ */
+export class BlocklistError extends ReputationError {
+    /**
+     * Creates a new blocklist error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, REPUTATION_BLOCKLIST_ERROR, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+    /**
+     * Creates an instance for an entity found on a blocklist
+     *
+     * @param entity Entity type (domain, ip)
+     * @param entityId Entity identifier
+     * @param blocklist Blocklist name
+     * @param reason Reason for listing (if available)
+     * @param context Additional context
+     */
+    static entityBlocked(entity, entityId, blocklist, reason, context = {}) {
+        const reasonText = reason ? ` (${reason})` : '';
+        return new BlocklistError(`${entity.charAt(0).toUpperCase() + entity.slice(1)} ${entityId} is listed on blocklist ${blocklist}${reasonText}`, {
+            ...context,
+            data: {
+                ...context.data,
+                entity,
+                entityId,
+                blocklist,
+                reason
+            },
+            userMessage: `The ${entity} ${entityId} is on a blocklist. This may affect email deliverability.`
+        });
+    }
+}
+/**
+ * Error class for reputation update errors
+ */
+export class ReputationUpdateError extends ReputationError {
+    /**
+     * Creates a new reputation update error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, REPUTATION_UPDATE_ERROR, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+}
+/**
+ * Error class for IP warmup allocation errors
+ */
+export class WarmupAllocationError extends ReputationError {
+    /**
+     * Creates a new warmup allocation error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, WARMUP_ALLOCATION_ERROR, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+    /**
+     * Creates an instance for no available IPs
+     *
+     * @param domain Domain requesting an IP
+     * @param policy Allocation policy that was used
+     * @param context Additional context
+     */
+    static noAvailableIps(domain, policy, context = {}) {
+        return new WarmupAllocationError(`No available IPs for domain ${domain} using ${policy} allocation policy`, {
+            ...context,
+            data: {
+                ...context.data,
+                domain,
+                policy
+            },
+            userMessage: `No available sending IPs for ${domain}.`
+        });
+    }
+}
+/**
+ * Error class for IP warmup limit exceeded errors
+ */
+export class WarmupLimitError extends ResourceError {
+    /**
+     * Creates a new warmup limit error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, WARMUP_LIMIT_EXCEEDED, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+    /**
+     * Creates an instance for daily sending limit exceeded
+     *
+     * @param ip IP address
+     * @param domain Domain
+     * @param limit Daily limit
+     * @param sent Number of emails sent
+     * @param context Additional context
+     */
+    static dailyLimitExceeded(ip, domain, limit, sent, context = {}) {
+        return new WarmupLimitError(`Daily sending limit exceeded for IP ${ip} and domain ${domain}: ${sent}/${limit}`, {
+            ...context,
+            data: {
+                ...context.data,
+                ip,
+                domain,
+                limit,
+                sent
+            },
+            userMessage: `Daily sending limit reached for ${domain}.`
+        });
+    }
+}
+/**
+ * Error class for IP warmup schedule errors
+ */
+export class WarmupScheduleError extends ReputationError {
+    /**
+     * Creates a new warmup schedule error
+     *
+     * @param message Error message
+     * @param context Additional context
+     */
+    constructor(message, context = {}) {
+        super(message, WARMUP_SCHEDULE_ERROR, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, context);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/index.d.ts

@@ -0,0 +1,4 @@
+export * from './00_commitinfo_data.js';
+export * from './mail/index.js';
+export * from './classes.dcrouter.js';
+export declare const runCli: () => Promise<void>;

package/dist_ts/ts/index.js

@@ -0,0 +1,6 @@
+export * from './00_commitinfo_data.js';
+export * from './mail/index.js';
+// DcRouter
+export * from './classes.dcrouter.js';
+export const runCli = async () => { };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUJBQWlCLENBQUM7QUFFaEMsV0FBVztBQUNYLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLEtBQUssSUFBSSxFQUFFLEdBQUUsQ0FBQyxDQUFBIn0=

package/dist_ts/ts/logger.d.ts

@@ -0,0 +1,17 @@
+declare class StandardLogger {
+    private defaultContext;
+    private correlationId;
+    constructor();
+    log(level: 'error' | 'warn' | 'info' | 'success' | 'debug', message: string, context?: Record<string, any>): void;
+    error(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    success(message: string, context?: Record<string, any>): void;
+    debug(message: string, context?: Record<string, any>): void;
+    setContext(context: Record<string, any>, overwrite?: boolean): void;
+    setCorrelationId(id?: string | null): string;
+    getCorrelationId(): string | null;
+    clearCorrelationId(): void;
+}
+export declare const logger: StandardLogger;
+export {};

package/dist_ts/ts/logger.js

@@ -0,0 +1,77 @@
+import * as plugins from './plugins.js';
+import { randomUUID } from 'node:crypto';
+// Map NODE_ENV to valid TEnvironment
+const nodeEnv = process.env.NODE_ENV || 'production';
+const envMap = {
+    'development': 'local',
+    'test': 'test',
+    'staging': 'staging',
+    'production': 'production'
+};
+// Default Smartlog instance
+const baseLogger = new plugins.smartlog.Smartlog({
+    logContext: {
+        environment: envMap[nodeEnv] || 'production',
+        runtime: 'node',
+        zone: 'serve.zone',
+    }
+});
+// Extended logger compatible with the original enhanced logger API
+class StandardLogger {
+    constructor() {
+        this.defaultContext = {};
+        this.correlationId = null;
+    }
+    // Log methods
+    log(level, message, context = {}) {
+        const combinedContext = {
+            ...this.defaultContext,
+            ...context
+        };
+        if (this.correlationId) {
+            combinedContext.correlation_id = this.correlationId;
+        }
+        baseLogger.log(level, message, combinedContext);
+    }
+    error(message, context = {}) {
+        this.log('error', message, context);
+    }
+    warn(message, context = {}) {
+        this.log('warn', message, context);
+    }
+    info(message, context = {}) {
+        this.log('info', message, context);
+    }
+    success(message, context = {}) {
+        this.log('success', message, context);
+    }
+    debug(message, context = {}) {
+        this.log('debug', message, context);
+    }
+    // Context management
+    setContext(context, overwrite = false) {
+        if (overwrite) {
+            this.defaultContext = context;
+        }
+        else {
+            this.defaultContext = {
+                ...this.defaultContext,
+                ...context
+            };
+        }
+    }
+    // Correlation ID management
+    setCorrelationId(id = null) {
+        this.correlationId = id || randomUUID();
+        return this.correlationId;
+    }
+    getCorrelationId() {
+        return this.correlationId;
+    }
+    clearCorrelationId() {
+        this.correlationId = null;
+    }
+}
+// Export a singleton instance
+export const logger = new StandardLogger();
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/core/classes.bouncemanager.d.ts

@@ -0,0 +1,200 @@
+import type { Email } from './classes.email.js';
+/**
+ * Bounce types for categorizing the reasons for bounces
+ */
+export declare enum BounceType {
+    INVALID_RECIPIENT = "invalid_recipient",
+    DOMAIN_NOT_FOUND = "domain_not_found",
+    MAILBOX_FULL = "mailbox_full",
+    MAILBOX_INACTIVE = "mailbox_inactive",
+    BLOCKED = "blocked",
+    SPAM_RELATED = "spam_related",
+    POLICY_RELATED = "policy_related",
+    SERVER_UNAVAILABLE = "server_unavailable",
+    TEMPORARY_FAILURE = "temporary_failure",
+    QUOTA_EXCEEDED = "quota_exceeded",
+    NETWORK_ERROR = "network_error",
+    TIMEOUT = "timeout",
+    AUTO_RESPONSE = "auto_response",
+    CHALLENGE_RESPONSE = "challenge_response",
+    UNKNOWN = "unknown"
+}
+/**
+ * Hard vs soft bounce classification
+ */
+export declare enum BounceCategory {
+    HARD = "hard",
+    SOFT = "soft",
+    AUTO_RESPONSE = "auto_response",
+    UNKNOWN = "unknown"
+}
+/**
+ * Bounce data structure
+ */
+export interface BounceRecord {
+    id: string;
+    originalEmailId?: string;
+    recipient: string;
+    sender: string;
+    domain: string;
+    subject?: string;
+    bounceType: BounceType;
+    bounceCategory: BounceCategory;
+    timestamp: number;
+    smtpResponse?: string;
+    diagnosticCode?: string;
+    statusCode?: string;
+    headers?: Record<string, string>;
+    processed: boolean;
+    retryCount?: number;
+    nextRetryTime?: number;
+}
+/**
+ * Retry strategy configuration for soft bounces
+ */
+interface RetryStrategy {
+    maxRetries: number;
+    initialDelay: number;
+    maxDelay: number;
+    backoffFactor: number;
+}
+/**
+ * Manager for handling email bounces
+ */
+export declare class BounceManager {
+    private retryStrategy;
+    private bounceStore;
+    private bounceCache;
+    private suppressionList;
+    private storageManager?;
+    constructor(options?: {
+        retryStrategy?: Partial<RetryStrategy>;
+        maxCacheSize?: number;
+        cacheTTL?: number;
+        storageManager?: any;
+    });
+    /**
+     * Process a bounce notification
+     * @param bounceData Bounce data to process
+     * @returns Processed bounce record
+     */
+    processBounce(bounceData: Partial<BounceRecord>): Promise<BounceRecord>;
+    /**
+     * Process an SMTP failure as a bounce
+     * @param recipient Recipient email
+     * @param smtpResponse SMTP error response
+     * @param options Additional options
+     * @returns Processed bounce record
+     */
+    processSmtpFailure(recipient: string, smtpResponse: string, options?: {
+        sender?: string;
+        originalEmailId?: string;
+        statusCode?: string;
+        headers?: Record<string, string>;
+    }): Promise<BounceRecord>;
+    /**
+     * Process a bounce notification email
+     * @param bounceEmail The email containing bounce information
+     * @returns Processed bounce record or null if not a bounce
+     */
+    processBounceEmail(bounceEmail: Email): Promise<BounceRecord | null>;
+    /**
+     * Handle a hard bounce by adding to suppression list
+     * @param bounce The bounce record
+     */
+    private handleHardBounce;
+    /**
+     * Handle a soft bounce by scheduling a retry if eligible
+     * @param bounce The bounce record
+     */
+    private handleSoftBounce;
+    /**
+     * Add an email address to the suppression list
+     * @param email Email address to suppress
+     * @param reason Reason for suppression
+     * @param expiresAt Expiration timestamp (undefined for permanent)
+     */
+    addToSuppressionList(email: string, reason: string, expiresAt?: number): void;
+    /**
+     * Remove an email address from the suppression list
+     * @param email Email address to remove
+     */
+    removeFromSuppressionList(email: string): void;
+    /**
+     * Check if an email is on the suppression list
+     * @param email Email address to check
+     * @returns Whether the email is suppressed
+     */
+    isEmailSuppressed(email: string): boolean;
+    /**
+     * Get suppression information for an email
+     * @param email Email address to check
+     * @returns Suppression information or null if not suppressed
+     */
+    getSuppressionInfo(email: string): {
+        reason: string;
+        timestamp: number;
+        expiresAt?: number;
+    } | null;
+    /**
+     * Save suppression list to disk
+     */
+    private saveSuppressionList;
+    /**
+     * Load suppression list from disk
+     */
+    private loadSuppressionList;
+    /**
+     * Save bounce record to disk
+     * @param bounce Bounce record to save
+     */
+    private saveBounceRecord;
+    /**
+     * Update bounce cache with new bounce information
+     * @param bounce Bounce record to update cache with
+     */
+    private updateBounceCache;
+    /**
+     * Check bounce history for an email address
+     * @param email Email address to check
+     * @returns Bounce information or null if no bounces
+     */
+    getBounceInfo(email: string): {
+        lastBounce: number;
+        count: number;
+        type: BounceType;
+        category: BounceCategory;
+    } | null;
+    /**
+     * Analyze SMTP response and diagnostic codes to determine bounce type
+     * @param smtpResponse SMTP response string
+     * @param diagnosticCode Diagnostic code from bounce
+     * @param statusCode Status code from bounce
+     * @returns Detected bounce type and category
+     */
+    private detectBounceType;
+    /**
+     * Check if text matches any pattern for a bounce type
+     * @param text Text to check against patterns
+     * @param bounceType Bounce type to get patterns for
+     * @returns Whether the text matches any pattern
+     */
+    private matchesPattern;
+    /**
+     * Get all known hard bounced addresses
+     * @returns Array of hard bounced email addresses
+     */
+    getHardBouncedAddresses(): string[];
+    /**
+     * Get suppression list
+     * @returns Array of suppressed email addresses
+     */
+    getSuppressionList(): string[];
+    /**
+     * Clear old bounce records (for maintenance)
+     * @param olderThan Timestamp to remove records older than
+     * @returns Number of records removed
+     */
+    clearOldBounceRecords(olderThan: number): number;
+}
+export {};