@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/deliverability/index.d.ts

@@ -0,0 +1,2 @@
+export { IPWarmupManager, type IIPWarmupConfig, type IWarmupStage, type IIPWarmupStatus, type IIPAllocationPolicy } from './classes.ipwarmupmanager.js';
+export { SenderReputationMonitor, type IDomainReputationMetrics, type IReputationMonitorConfig } from './classes.senderreputationmonitor.js';

package/dist_ts/ts/deliverability/index.js

@@ -0,0 +1,3 @@
+export { IPWarmupManager } from './classes.ipwarmupmanager.js';
+export { SenderReputationMonitor } from './classes.senderreputationmonitor.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9kZWxpdmVyYWJpbGl0eS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUtoQixNQUFNLDhCQUE4QixDQUFDO0FBRXRDLE9BQU8sRUFDTCx1QkFBdUIsRUFHeEIsTUFBTSxzQ0FBc0MsQ0FBQyJ9

package/dist_ts/ts/errors/base.errors.d.ts

@@ -0,0 +1,224 @@
+import { ErrorSeverity, ErrorCategory, ErrorRecoverability } from './error.codes.js';
+/**
+ * Context information added to structured errors
+ */
+export interface IErrorContext {
+    /** Component or service where the error occurred */
+    component?: string;
+    /** Operation that was being performed */
+    operation?: string;
+    /** Unique request ID if available */
+    requestId?: string;
+    /** Error occurred at timestamp */
+    timestamp?: number;
+    /** User-visible message (safe to display to end-users) */
+    userMessage?: string;
+    /** Additional structured data for debugging */
+    data?: Record<string, any>;
+    /** Related entity IDs if applicable */
+    entity?: {
+        type: string;
+        id: string | number;
+    };
+    /** Stack trace (if enabled in configuration) */
+    stack?: string;
+    /** Retry information if applicable */
+    retry?: {
+        /** Maximum number of retries allowed */
+        maxRetries?: number;
+        /** Current retry count */
+        currentRetry?: number;
+        /** Next retry timestamp */
+        nextRetryAt?: number;
+        /** Delay between retries (in ms) */
+        retryDelay?: number;
+    };
+}
+/**
+ * Base class for all errors in the Platform Service
+ * Adds structured error information, logging, and error tracking
+ */
+export declare class PlatformError extends Error {
+    /** Error code identifying the specific error type */
+    readonly code: string;
+    /** Error severity level */
+    readonly severity: ErrorSeverity;
+    /** Error category for grouping related errors */
+    readonly category: ErrorCategory;
+    /** Whether the error can be recovered from automatically */
+    readonly recoverability: ErrorRecoverability;
+    /** Additional context information */
+    readonly context: IErrorContext;
+    /**
+     * Creates a new PlatformError
+     *
+     * @param message Error message
+     * @param code Error code from error.codes.ts
+     * @param severity Error severity level
+     * @param category Error category
+     * @param recoverability Error recoverability indication
+     * @param context Additional context information
+     */
+    constructor(message: string, code: string, severity?: ErrorSeverity, category?: ErrorCategory, recoverability?: ErrorRecoverability, context?: IErrorContext);
+    /**
+     * Logs the error using the platform logger
+     */
+    private logError;
+    /**
+     * Maps severity levels to log levels
+     */
+    private getLogLevelFromSeverity;
+    /**
+     * Returns a JSON representation of the error
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Creates an instance with retry information
+     *
+     * @param maxRetries Maximum number of retries
+     * @param currentRetry Current retry count
+     * @param retryDelay Delay between retries in ms
+     */
+    withRetry(maxRetries: number, currentRetry?: number, retryDelay?: number): PlatformError;
+    /**
+     * Protected method to create a new instance with updated context
+     * Subclasses can override this to handle their own constructor signatures
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+    /**
+     * Checks if the error should be retried based on retry information
+     */
+    shouldRetry(): boolean;
+    /**
+     * Returns a user-friendly message that is safe to display to end users
+     */
+    getUserMessage(): string;
+}
+/**
+ * Error class for validation errors
+ */
+export declare class ValidationError extends PlatformError {
+    /**
+     * Creates a new validation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ValidationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for configuration errors
+ */
+export declare class ConfigurationError extends PlatformError {
+    /**
+     * Creates a new configuration error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ConfigurationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for network-related errors
+ */
+export declare class NetworkError extends PlatformError {
+    /**
+     * Creates a new network error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle NetworkError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for resource availability errors (rate limits, quotas)
+ */
+export declare class ResourceError extends PlatformError {
+    /**
+     * Creates a new resource error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ResourceError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for authentication/authorization errors
+ */
+export declare class AuthenticationError extends PlatformError {
+    /**
+     * Creates a new authentication error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle AuthenticationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for operation errors (API calls, processing)
+ */
+export declare class OperationError extends PlatformError {
+    /**
+     * Creates a new operation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle OperationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for critical system errors
+ */
+export declare class SystemError extends PlatformError {
+    /**
+     * Creates a new system error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+}
+/**
+ * Helper to get the appropriate error class based on error category
+ *
+ * @param category Error category
+ * @returns The appropriate error class
+ */
+export declare function getErrorClassForCategory(category: ErrorCategory): any;

package/dist_ts/ts/errors/base.errors.js

@@ -0,0 +1,310 @@
+import { ErrorSeverity, ErrorCategory, ErrorRecoverability } from './error.codes.js';
+import { logger } from '../logger.js';
+/**
+ * Base class for all errors in the Platform Service
+ * Adds structured error information, logging, and error tracking
+ */
+export class PlatformError extends Error {
+    /**
+     * Creates a new PlatformError
+     *
+     * @param message Error message
+     * @param code Error code from error.codes.ts
+     * @param severity Error severity level
+     * @param category Error category
+     * @param recoverability Error recoverability indication
+     * @param context Additional context information
+     */
+    constructor(message, code, severity = ErrorSeverity.MEDIUM, category = ErrorCategory.OTHER, recoverability = ErrorRecoverability.NON_RECOVERABLE, context = {}) {
+        super(message);
+        // Set error metadata
+        this.name = this.constructor.name;
+        this.code = code;
+        this.severity = severity;
+        this.category = category;
+        this.recoverability = recoverability;
+        // Add timestamp if not provided
+        this.context = {
+            ...context,
+            timestamp: context.timestamp || Date.now(),
+        };
+        // Capture stack trace
+        Error.captureStackTrace(this, this.constructor);
+        // Log the error automatically unless explicitly disabled
+        if (!context.data?.skipLogging) {
+            this.logError();
+        }
+    }
+    /**
+     * Logs the error using the platform logger
+     */
+    logError() {
+        const logLevel = this.getLogLevelFromSeverity();
+        // Construct structured log entry
+        const logData = {
+            error_code: this.code,
+            error_name: this.name,
+            severity: this.severity,
+            category: this.category,
+            recoverability: this.recoverability,
+            ...this.context
+        };
+        // Log with appropriate level
+        logger.log(logLevel, this.message, logData);
+    }
+    /**
+     * Maps severity levels to log levels
+     */
+    getLogLevelFromSeverity() {
+        switch (this.severity) {
+            case ErrorSeverity.CRITICAL:
+            case ErrorSeverity.HIGH:
+                return 'error';
+            case ErrorSeverity.MEDIUM:
+                return 'warn';
+            case ErrorSeverity.LOW:
+                return 'info';
+            case ErrorSeverity.INFO:
+                return 'debug';
+            default:
+                return 'error';
+        }
+    }
+    /**
+     * Returns a JSON representation of the error
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            severity: this.severity,
+            category: this.category,
+            recoverability: this.recoverability,
+            context: this.context,
+            stack: process.env.NODE_ENV !== 'production' ? this.stack : undefined
+        };
+    }
+    /**
+     * Creates an instance with retry information
+     *
+     * @param maxRetries Maximum number of retries
+     * @param currentRetry Current retry count
+     * @param retryDelay Delay between retries in ms
+     */
+    withRetry(maxRetries, currentRetry = 0, retryDelay = 1000) {
+        const nextRetryAt = Date.now() + retryDelay;
+        // Clone the error with updated context
+        const newContext = {
+            ...this.context,
+            retry: {
+                maxRetries,
+                currentRetry,
+                nextRetryAt,
+                retryDelay
+            }
+        };
+        // Create a new instance using the protected method that subclasses can override
+        const newError = this.createWithContext(newContext);
+        // Update recoverability if we can retry
+        if (currentRetry < maxRetries && newError.recoverability === ErrorRecoverability.NON_RECOVERABLE) {
+            newError.recoverability = ErrorRecoverability.MAYBE_RECOVERABLE;
+        }
+        return newError;
+    }
+    /**
+     * Protected method to create a new instance with updated context
+     * Subclasses can override this to handle their own constructor signatures
+     */
+    createWithContext(context) {
+        // Default implementation for PlatformError
+        return new this.constructor(this.message, this.code, this.severity, this.category, this.recoverability, context);
+    }
+    /**
+     * Checks if the error should be retried based on retry information
+     */
+    shouldRetry() {
+        const { retry } = this.context;
+        if (!retry)
+            return false;
+        return retry.currentRetry < retry.maxRetries;
+    }
+    /**
+     * Returns a user-friendly message that is safe to display to end users
+     */
+    getUserMessage() {
+        return this.context.userMessage || 'An unexpected error occurred.';
+    }
+}
+/**
+ * Error class for validation errors
+ */
+export class ValidationError extends PlatformError {
+    /**
+     * Creates a new validation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.LOW, ErrorCategory.VALIDATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ValidationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for configuration errors
+ */
+export class ConfigurationError extends PlatformError {
+    /**
+     * Creates a new configuration error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.CONFIGURATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ConfigurationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for network-related errors
+ */
+export class NetworkError extends PlatformError {
+    /**
+     * Creates a new network error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.CONNECTIVITY, ErrorRecoverability.MAYBE_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle NetworkError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for resource availability errors (rate limits, quotas)
+ */
+export class ResourceError extends PlatformError {
+    /**
+     * Creates a new resource error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.RESOURCE, ErrorRecoverability.MAYBE_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ResourceError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for authentication/authorization errors
+ */
+export class AuthenticationError extends PlatformError {
+    /**
+     * Creates a new authentication error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.HIGH, ErrorCategory.AUTHENTICATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle AuthenticationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for operation errors (API calls, processing)
+ */
+export class OperationError extends PlatformError {
+    /**
+     * Creates a new operation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.OPERATION, ErrorRecoverability.MAYBE_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle OperationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for critical system errors
+ */
+export class SystemError extends PlatformError {
+    /**
+     * Creates a new system error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.CRITICAL, ErrorCategory.OTHER, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+}
+/**
+ * Helper to get the appropriate error class based on error category
+ *
+ * @param category Error category
+ * @returns The appropriate error class
+ */
+export function getErrorClassForCategory(category) {
+    switch (category) {
+        case ErrorCategory.VALIDATION:
+            return ValidationError;
+        case ErrorCategory.CONFIGURATION:
+            return ConfigurationError;
+        case ErrorCategory.CONNECTIVITY:
+            return NetworkError;
+        case ErrorCategory.RESOURCE:
+            return ResourceError;
+        case ErrorCategory.AUTHENTICATION:
+            return AuthenticationError;
+        case ErrorCategory.OPERATION:
+            return OperationError;
+        default:
+            return PlatformError;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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