@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/errors/error-handler.js

@@ -0,0 +1,282 @@
+import { PlatformError } from './base.errors.js';
+import { ErrorCategory, ErrorRecoverability, ErrorSeverity } from './error.codes.js';
+import { logger } from '../logger.js';
+/**
+ * Global error handler configuration
+ */
+const config = {
+    logErrors: true,
+    includeStacksInProd: false,
+    retry: {
+        maxAttempts: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        backoffFactor: 2
+    }
+};
+/**
+ * Error handler utility
+ * Provides methods for consistent error handling across the platform
+ */
+export class ErrorHandler {
+    /**
+     * Current configuration
+     */
+    static { this.config = config; }
+    /**
+     * Update error handler configuration
+     *
+     * @param newConfig New configuration (partial)
+     */
+    static configure(newConfig) {
+        ErrorHandler.config = {
+            ...ErrorHandler.config,
+            ...newConfig,
+            retry: {
+                ...ErrorHandler.config.retry,
+                ...(newConfig.retry || {})
+            }
+        };
+    }
+    /**
+     * Convert any error to a PlatformError
+     *
+     * @param error Error to convert
+     * @param defaultCode Default error code if not a PlatformError
+     * @param context Additional context
+     * @returns PlatformError instance
+     */
+    static toPlatformError(error, defaultCode, context = {}) {
+        // If already a PlatformError, just add context
+        if (error instanceof PlatformError) {
+            // Add context if provided
+            if (Object.keys(context).length > 0) {
+                return new error.constructor(error.message, error.code, error.severity, error.category, error.recoverability, {
+                    ...error.context,
+                    ...context,
+                    data: {
+                        ...(error.context.data || {}),
+                        ...(context.data || {})
+                    }
+                });
+            }
+            return error;
+        }
+        // Convert standard Error to PlatformError
+        if (error instanceof Error) {
+            return new PlatformError(error.message, defaultCode, ErrorSeverity.MEDIUM, ErrorCategory.OPERATION, ErrorRecoverability.NON_RECOVERABLE, {
+                ...context,
+                data: {
+                    ...(context.data || {}),
+                    originalError: {
+                        name: error.name,
+                        message: error.message,
+                        stack: error.stack
+                    }
+                }
+            });
+        }
+        // Not an Error instance
+        return new PlatformError(typeof error === 'string' ? error : 'Unknown error', defaultCode, ErrorSeverity.MEDIUM, ErrorCategory.OPERATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Format an error for API responses
+     * Sanitizes errors for safe external exposure
+     *
+     * @param error Error to format
+     * @param includeDetails Whether to include detailed information
+     * @returns Formatted error object
+     */
+    static formatErrorForResponse(error, includeDetails = false) {
+        const platformError = ErrorHandler.toPlatformError(error, 'PLATFORM_OPERATION_ERROR');
+        // Basic error information
+        const responseError = {
+            code: platformError.code,
+            message: platformError.getUserMessage(),
+            requestId: platformError.context.requestId
+        };
+        // Include more details if requested
+        if (includeDetails) {
+            responseError.details = {
+                severity: platformError.severity,
+                category: platformError.category,
+                rawMessage: platformError.message,
+                data: platformError.context.data
+            };
+            // Only include stack trace in non-production or if explicitly enabled
+            if (process.env.NODE_ENV !== 'production' || ErrorHandler.config.includeStacksInProd) {
+                responseError.details.stack = platformError.stack;
+            }
+        }
+        return responseError;
+    }
+    /**
+     * Handle an error with consistent logging and formatting
+     *
+     * @param error Error to handle
+     * @param defaultCode Default error code if not a PlatformError
+     * @param context Additional context
+     * @returns Formatted error for response
+     */
+    static handleError(error, defaultCode, context = {}) {
+        const platformError = ErrorHandler.toPlatformError(error, defaultCode, context);
+        // Log the error if enabled
+        if (ErrorHandler.config.logErrors) {
+            logger.error(platformError.message, {
+                error_code: platformError.code,
+                error_name: platformError.name,
+                error_severity: platformError.severity,
+                error_category: platformError.category,
+                error_recoverability: platformError.recoverability,
+                ...platformError.context,
+                stack: platformError.stack
+            });
+        }
+        // Return formatted error for response
+        const isDetailedMode = process.env.NODE_ENV !== 'production';
+        return ErrorHandler.formatErrorForResponse(platformError, isDetailedMode);
+    }
+    /**
+     * Execute a function with error handling
+     *
+     * @param fn Function to execute
+     * @param defaultCode Default error code if the function throws
+     * @param context Additional context
+     * @returns Function result or error
+     */
+    static async execute(fn, defaultCode, context = {}) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            throw ErrorHandler.toPlatformError(error, defaultCode, context);
+        }
+    }
+    /**
+     * Execute a function with retries and exponential backoff
+     *
+     * @param fn Function to execute
+     * @param defaultCode Default error code if the function throws
+     * @param options Retry options
+     * @param context Additional context
+     * @returns Function result or error after max retries
+     */
+    static async executeWithRetry(fn, defaultCode, options = {}, context = {}) {
+        const { maxAttempts = ErrorHandler.config.retry.maxAttempts, baseDelay = ErrorHandler.config.retry.baseDelay, maxDelay = ErrorHandler.config.retry.maxDelay, backoffFactor = ErrorHandler.config.retry.backoffFactor, retryableErrorCodes = [], retryableErrorPatterns = [], onRetry = () => { } } = options;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                // Convert to PlatformError
+                const platformError = ErrorHandler.toPlatformError(error, defaultCode, {
+                    ...context,
+                    retry: {
+                        currentRetry: attempt,
+                        maxRetries: maxAttempts,
+                        nextRetryAt: 0 // Will be set below if retrying
+                    }
+                });
+                lastError = platformError;
+                // Check if we should retry
+                const isLastAttempt = attempt >= maxAttempts - 1;
+                if (isLastAttempt) {
+                    // No more retries
+                    throw platformError;
+                }
+                // Check if error is retryable
+                const isRetryable = 
+                // Built-in recoverability
+                platformError.recoverability === ErrorRecoverability.RECOVERABLE ||
+                    platformError.recoverability === ErrorRecoverability.MAYBE_RECOVERABLE ||
+                    platformError.recoverability === ErrorRecoverability.TRANSIENT ||
+                    // Specifically included error codes
+                    retryableErrorCodes.includes(platformError.code) ||
+                    // Matches error message patterns
+                    retryableErrorPatterns.some(pattern => pattern.test(platformError.message));
+                if (!isRetryable) {
+                    throw platformError;
+                }
+                // Calculate delay with exponential backoff
+                const delay = Math.min(baseDelay * Math.pow(backoffFactor, attempt), maxDelay);
+                // Add jitter to prevent thundering herd problem (±20%)
+                const jitter = 0.8 + Math.random() * 0.4;
+                const actualDelay = Math.floor(delay * jitter);
+                // Update nextRetryAt in error context
+                const nextRetryAt = Date.now() + actualDelay;
+                platformError.context.retry.nextRetryAt = nextRetryAt;
+                // Log retry attempt
+                logger.warn(`Retrying operation after error (attempt ${attempt + 1}/${maxAttempts}): ${platformError.message}`, {
+                    error_code: platformError.code,
+                    retry_attempt: attempt + 1,
+                    retry_max_attempts: maxAttempts,
+                    retry_delay_ms: actualDelay,
+                    retry_next_at: new Date(nextRetryAt).toISOString()
+                });
+                // Call onRetry callback
+                onRetry(platformError, attempt + 1, actualDelay);
+                // Wait before next retry
+                await new Promise(resolve => setTimeout(resolve, actualDelay));
+            }
+        }
+        // This should never happen, but TypeScript needs it
+        throw lastError;
+    }
+}
+/**
+ * Create a middleware for handling errors in HTTP requests
+ *
+ * @returns Middleware function
+ */
+export function createErrorHandlerMiddleware() {
+    return (error, req, res, next) => {
+        // Add request context
+        const context = {
+            requestId: req.headers['x-request-id'] || req.headers['x-correlation-id'],
+            component: 'HttpServer',
+            operation: `${req.method} ${req.url}`,
+            data: {
+                method: req.method,
+                url: req.url,
+                query: req.query,
+                params: req.params,
+                ip: req.ip || req.connection.remoteAddress,
+                userAgent: req.headers['user-agent']
+            }
+        };
+        // Handle the error
+        const formattedError = ErrorHandler.handleError(error, 'PLATFORM_OPERATION_ERROR', context);
+        // Set status code based on error type
+        let statusCode = 500;
+        if (error instanceof PlatformError) {
+            // Map error categories to HTTP status codes
+            switch (error.category) {
+                case ErrorCategory.VALIDATION:
+                    statusCode = 400;
+                    break;
+                case ErrorCategory.AUTHENTICATION:
+                    statusCode = 401;
+                    break;
+                case ErrorCategory.RESOURCE:
+                    statusCode = 429;
+                    break;
+                case ErrorCategory.OPERATION:
+                    statusCode = 400;
+                    break;
+                default:
+                    statusCode = 500;
+            }
+        }
+        else if (error.statusCode) {
+            // Use provided status code if available
+            statusCode = error.statusCode;
+        }
+        // Send error response
+        res.status(statusCode).json({
+            success: false,
+            error: formattedError
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.js","sourceRoot":"","sources":["../../../ts/errors/error-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AA4BtC;;GAEG;AACH,MAAM,MAAM,GAAwB;IAClC,SAAS,EAAE,IAAI;IACf,mBAAmB,EAAE,KAAK;IAC1B,KAAK,EAAE;QACL,WAAW,EAAE,CAAC;QACd,SAAS,EAAE,IAAI;QACf,QAAQ,EAAE,KAAK;QACf,aAAa,EAAE,CAAC;KACjB;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,OAAO,YAAY;IACvB;;OAEG;aACW,WAAM,GAAG,MAAM,CAAC;IAE9B;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,SAAuC;QAC7D,YAAY,CAAC,MAAM,GAAG;YACpB,GAAG,YAAY,CAAC,MAAM;YACtB,GAAG,SAAS;YACZ,KAAK,EAAE;gBACL,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK;gBAC5B,GAAG,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;aAC3B;SACF,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,eAAe,CAC3B,KAAU,EACV,WAAmB,EACnB,UAAyB,EAAE;QAE3B,+CAA+C;QAC/C,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,0BAA0B;YAC1B,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpC,OAAO,IAAK,KAAK,CAAC,WAAoC,CACpD,KAAK,CAAC,OAAO,EACb,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,cAAc,EACpB;oBACE,GAAG,KAAK,CAAC,OAAO;oBAChB,GAAG,OAAO;oBACV,IAAI,EAAE;wBACJ,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;wBAC7B,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;qBACxB;iBACF,CACF,CAAC;YACJ,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,0CAA0C;QAC1C,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,OAAO,IAAI,aAAa,CACtB,KAAK,CAAC,OAAO,EACb,WAAW,EACX,aAAa,CAAC,MAAM,EACpB,aAAa,CAAC,SAAS,EACvB,mBAAmB,CAAC,eAAe,EACnC;gBACE,GAAG,OAAO;gBACV,IAAI,EAAE;oBACJ,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;oBACvB,aAAa,EAAE;wBACb,IAAI,EAAE,KAAK,CAAC,IAAI;wBAChB,OAAO,EAAE,KAAK,CAAC,OAAO;wBACtB,KAAK,EAAE,KAAK,CAAC,KAAK;qBACnB;iBACF;aACF,CACF,CAAC;QACJ,CAAC;QAED,wBAAwB;QACxB,OAAO,IAAI,aAAa,CACtB,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,eAAe,EACnD,WAAW,EACX,aAAa,CAAC,MAAM,EACpB,aAAa,CAAC,SAAS,EACvB,mBAAmB,CAAC,eAAe,EACnC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,sBAAsB,CAClC,KAAU,EACV,iBAA0B,KAAK;QAE/B,MAAM,aAAa,GAAG,YAAY,CAAC,eAAe,CAChD,KAAK,EACL,0BAA0B,CAC3B,CAAC;QAEF,0BAA0B;QAC1B,MAAM,aAAa,GAAwB;YACzC,IAAI,EAAE,aAAa,CAAC,IAAI;YACxB,OAAO,EAAE,aAAa,CAAC,cAAc,EAAE;YACvC,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,SAAS;SAC3C,CAAC;QAEF,oCAAoC;QACpC,IAAI,cAAc,EAAE,CAAC;YACnB,aAAa,CAAC,OAAO,GAAG;gBACtB,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,UAAU,EAAE,aAAa,CAAC,OAAO;gBACjC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,IAAI;aACjC,CAAC;YAEF,sEAAsE;YACtE,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,IAAI,YAAY,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;gBACrF,aAAa,CAAC,OAAO,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC;YACpD,CAAC;QACH,CAAC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,WAAW,CACvB,KAAU,EACV,WAAmB,EACnB,UAAyB,EAAE;QAE3B,MAAM,aAAa,GAAG,YAAY,CAAC,eAAe,CAChD,KAAK,EACL,WAAW,EACX,OAAO,CACR,CAAC;QAEF,2BAA2B;QAC3B,IAAI,YAAY,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;YAClC,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,EAAE;gBAClC,UAAU,EAAE,aAAa,CAAC,IAAI;gBAC9B,UAAU,EAAE,aAAa,CAAC,IAAI;gBAC9B,cAAc,EAAE,aAAa,CAAC,QAAQ;gBACtC,cAAc,EAAE,aAAa,CAAC,QAAQ;gBACtC,oBAAoB,EAAE,aAAa,CAAC,cAAc;gBAClD,GAAG,aAAa,CAAC,OAAO;gBACxB,KAAK,EAAE,aAAa,CAAC,KAAK;aAC3B,CAAC,CAAC;QACL,CAAC;QAED,sCAAsC;QACtC,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC;QAC7D,OAAO,YAAY,CAAC,sBAAsB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,KAAK,CAAC,OAAO,CACzB,EAAoB,EACpB,WAAmB,EACnB,UAAyB,EAAE;QAE3B,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,EAAE,CAAC;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAClC,EAAoB,EACpB,WAAmB,EACnB,UAQI,EAAE,EACN,UAAyB,EAAE;QAE3B,MAAM,EACJ,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,EACnD,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAC/C,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,EAC7C,aAAa,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,EACvD,mBAAmB,GAAG,EAAE,EACxB,sBAAsB,GAAG,EAAE,EAC3B,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,EACnB,GAAG,OAAO,CAAC;QAEZ,IAAI,SAAwB,CAAC;QAE7B,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;YACvD,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,2BAA2B;gBAC3B,MAAM,aAAa,GAAG,YAAY,CAAC,eAAe,CAChD,KAAK,EACL,WAAW,EACX;oBACE,GAAG,OAAO;oBACV,KAAK,EAAE;wBACL,YAAY,EAAE,OAAO;wBACrB,UAAU,EAAE,WAAW;wBACvB,WAAW,EAAE,CAAC,CAAC,gCAAgC;qBAChD;iBACF,CACF,CAAC;gBAEF,SAAS,GAAG,aAAa,CAAC;gBAE1B,2BAA2B;gBAC3B,MAAM,aAAa,GAAG,OAAO,IAAI,WAAW,GAAG,CAAC,CAAC;gBAEjD,IAAI,aAAa,EAAE,CAAC;oBAClB,kBAAkB;oBAClB,MAAM,aAAa,CAAC;gBACtB,CAAC;gBAED,8BAA8B;gBAC9B,MAAM,WAAW;gBACf,0BAA0B;gBAC1B,aAAa,CAAC,cAAc,KAAK,mBAAmB,CAAC,WAAW;oBAChE,aAAa,CAAC,cAAc,KAAK,mBAAmB,CAAC,iBAAiB;oBACtE,aAAa,CAAC,cAAc,KAAK,mBAAmB,CAAC,SAAS;oBAC9D,oCAAoC;oBACpC,mBAAmB,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC;oBAChD,iCAAiC;oBACjC,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;gBAE9E,IAAI,CAAC,WAAW,EAAE,CAAC;oBACjB,MAAM,aAAa,CAAC;gBACtB,CAAC;gBAED,2CAA2C;gBAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;gBAE/E,uDAAuD;gBACvD,MAAM,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC;gBACzC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC;gBAE/C,sCAAsC;gBACtC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,WAAW,CAAC;gBAC7C,aAAa,CAAC,OAAO,CAAC,KAAM,CAAC,WAAW,GAAG,WAAW,CAAC;gBAEvD,oBAAoB;gBACpB,MAAM,CAAC,IAAI,CAAC,2CAA2C,OAAO,GAAG,CAAC,IAAI,WAAW,MAAM,aAAa,CAAC,OAAO,EAAE,EAAE;oBAC9G,UAAU,EAAE,aAAa,CAAC,IAAI;oBAC9B,aAAa,EAAE,OAAO,GAAG,CAAC;oBAC1B,kBAAkB,EAAE,WAAW;oBAC/B,cAAc,EAAE,WAAW;oBAC3B,aAAa,EAAE,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE;iBACnD,CAAC,CAAC;gBAEH,wBAAwB;gBACxB,OAAO,CAAC,aAAa,EAAE,OAAO,GAAG,CAAC,EAAE,WAAW,CAAC,CAAC;gBAEjD,yBAAyB;gBACzB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;QAED,oDAAoD;QACpD,MAAM,SAAU,CAAC;IACnB,CAAC;;AAGH;;;;GAIG;AACH,MAAM,UAAU,4BAA4B;IAC1C,OAAO,CAAC,KAAU,EAAE,GAAQ,EAAE,GAAQ,EAAE,IAAS,EAAE,EAAE;QACnD,sBAAsB;QACtB,MAAM,OAAO,GAAkB;YAC7B,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,kBAAkB,CAAC;YACzE,SAAS,EAAE,YAAY;YACvB,SAAS,EAAE,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,GAAG,EAAE;YACrC,IAAI,EAAE;gBACJ,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,GAAG,EAAE,GAAG,CAAC,GAAG;gBACZ,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,EAAE,EAAE,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,UAAU,CAAC,aAAa;gBAC1C,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC;aACrC;SACF,CAAC;QAEF,mBAAmB;QACnB,MAAM,cAAc,GAAG,YAAY,CAAC,WAAW,CAC7C,KAAK,EACL,0BAA0B,EAC1B,OAAO,CACR,CAAC;QAEF,sCAAsC;QACtC,IAAI,UAAU,GAAG,GAAG,CAAC;QAErB,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,4CAA4C;YAC5C,QAAQ,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACvB,KAAK,aAAa,CAAC,UAAU;oBAC3B,UAAU,GAAG,GAAG,CAAC;oBACjB,MAAM;gBACR,KAAK,aAAa,CAAC,cAAc;oBAC/B,UAAU,GAAG,GAAG,CAAC;oBACjB,MAAM;gBACR,KAAK,aAAa,CAAC,QAAQ;oBACzB,UAAU,GAAG,GAAG,CAAC;oBACjB,MAAM;gBACR,KAAK,aAAa,CAAC,SAAS;oBAC1B,UAAU,GAAG,GAAG,CAAC;oBACjB,MAAM;gBACR;oBACE,UAAU,GAAG,GAAG,CAAC;YACrB,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YAC5B,wCAAwC;YACxC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAChC,CAAC;QAED,sBAAsB;QACtB,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC;YAC1B,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,cAAc;SACtB,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}

package/dist_ts/ts/errors/error.codes.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Platform Service Error Codes
+ *
+ * This file contains all error codes used across the platform service.
+ *
+ * Format: PREFIX_ERROR_TYPE
+ * - PREFIX: Component/domain prefix (e.g., EMAIL, MTA, SMS)
+ * - ERROR_TYPE: Specific error type within the domain
+ */
+export declare const PLATFORM_INITIALIZATION_ERROR = "PLATFORM_INITIALIZATION_ERROR";
+export declare const PLATFORM_CONFIGURATION_ERROR = "PLATFORM_CONFIGURATION_ERROR";
+export declare const PLATFORM_OPERATION_ERROR = "PLATFORM_OPERATION_ERROR";
+export declare const PLATFORM_NOT_IMPLEMENTED = "PLATFORM_NOT_IMPLEMENTED";
+export declare const PLATFORM_NOT_SUPPORTED = "PLATFORM_NOT_SUPPORTED";
+export declare const PLATFORM_SERVICE_UNAVAILABLE = "PLATFORM_SERVICE_UNAVAILABLE";
+export declare const EMAIL_SERVICE_ERROR = "EMAIL_SERVICE_ERROR";
+export declare const EMAIL_TEMPLATE_ERROR = "EMAIL_TEMPLATE_ERROR";
+export declare const EMAIL_VALIDATION_ERROR = "EMAIL_VALIDATION_ERROR";
+export declare const EMAIL_SEND_ERROR = "EMAIL_SEND_ERROR";
+export declare const EMAIL_RECEIVE_ERROR = "EMAIL_RECEIVE_ERROR";
+export declare const EMAIL_ATTACHMENT_ERROR = "EMAIL_ATTACHMENT_ERROR";
+export declare const EMAIL_PARSE_ERROR = "EMAIL_PARSE_ERROR";
+export declare const EMAIL_RATE_LIMIT_EXCEEDED = "EMAIL_RATE_LIMIT_EXCEEDED";
+export declare const MTA_CONNECTION_ERROR = "MTA_CONNECTION_ERROR";
+export declare const MTA_AUTHENTICATION_ERROR = "MTA_AUTHENTICATION_ERROR";
+export declare const MTA_DELIVERY_ERROR = "MTA_DELIVERY_ERROR";
+export declare const MTA_CONFIGURATION_ERROR = "MTA_CONFIGURATION_ERROR";
+export declare const MTA_DNS_ERROR = "MTA_DNS_ERROR";
+export declare const MTA_TIMEOUT_ERROR = "MTA_TIMEOUT_ERROR";
+export declare const MTA_PROTOCOL_ERROR = "MTA_PROTOCOL_ERROR";
+export declare const BOUNCE_PROCESSING_ERROR = "BOUNCE_PROCESSING_ERROR";
+export declare const BOUNCE_STORAGE_ERROR = "BOUNCE_STORAGE_ERROR";
+export declare const BOUNCE_CLASSIFICATION_ERROR = "BOUNCE_CLASSIFICATION_ERROR";
+export declare const AUTH_SPF_ERROR = "AUTH_SPF_ERROR";
+export declare const AUTH_DKIM_ERROR = "AUTH_DKIM_ERROR";
+export declare const AUTH_DMARC_ERROR = "AUTH_DMARC_ERROR";
+export declare const AUTH_KEY_ERROR = "AUTH_KEY_ERROR";
+export declare const SCAN_ANALYSIS_ERROR = "SCAN_ANALYSIS_ERROR";
+export declare const SCAN_MALWARE_DETECTED = "SCAN_MALWARE_DETECTED";
+export declare const SCAN_PHISHING_DETECTED = "SCAN_PHISHING_DETECTED";
+export declare const SCAN_CONTENT_REJECTED = "SCAN_CONTENT_REJECTED";
+export declare const REPUTATION_CHECK_ERROR = "REPUTATION_CHECK_ERROR";
+export declare const REPUTATION_DATA_ERROR = "REPUTATION_DATA_ERROR";
+export declare const REPUTATION_BLOCKLIST_ERROR = "REPUTATION_BLOCKLIST_ERROR";
+export declare const REPUTATION_UPDATE_ERROR = "REPUTATION_UPDATE_ERROR";
+export declare const WARMUP_ALLOCATION_ERROR = "WARMUP_ALLOCATION_ERROR";
+export declare const WARMUP_LIMIT_EXCEEDED = "WARMUP_LIMIT_EXCEEDED";
+export declare const WARMUP_SCHEDULE_ERROR = "WARMUP_SCHEDULE_ERROR";
+export declare const NETWORK_CONNECTION_ERROR = "NETWORK_CONNECTION_ERROR";
+export declare const NETWORK_TIMEOUT = "NETWORK_TIMEOUT";
+export declare const NETWORK_DNS_ERROR = "NETWORK_DNS_ERROR";
+export declare const NETWORK_TLS_ERROR = "NETWORK_TLS_ERROR";
+export declare const QUEUE_FULL_ERROR = "QUEUE_FULL_ERROR";
+export declare const QUEUE_PROCESSING_ERROR = "QUEUE_PROCESSING_ERROR";
+export declare const QUEUE_PERSISTENCE_ERROR = "QUEUE_PERSISTENCE_ERROR";
+export declare const QUEUE_ITEM_NOT_FOUND = "QUEUE_ITEM_NOT_FOUND";
+export declare const DCR_ROUTING_ERROR = "DCR_ROUTING_ERROR";
+export declare const DCR_CONFIGURATION_ERROR = "DCR_CONFIGURATION_ERROR";
+export declare const DCR_PROXY_ERROR = "DCR_PROXY_ERROR";
+export declare const DCR_DOMAIN_ERROR = "DCR_DOMAIN_ERROR";
+export declare const SMS_SERVICE_ERROR = "SMS_SERVICE_ERROR";
+export declare const SMS_SEND_ERROR = "SMS_SEND_ERROR";
+export declare const SMS_VALIDATION_ERROR = "SMS_VALIDATION_ERROR";
+export declare const SMS_RATE_LIMIT_EXCEEDED = "SMS_RATE_LIMIT_EXCEEDED";
+export declare const STORAGE_WRITE_ERROR = "STORAGE_WRITE_ERROR";
+export declare const STORAGE_READ_ERROR = "STORAGE_READ_ERROR";
+export declare const STORAGE_DELETE_ERROR = "STORAGE_DELETE_ERROR";
+export declare const STORAGE_QUOTA_EXCEEDED = "STORAGE_QUOTA_EXCEEDED";
+export declare const RULE_VALIDATION_ERROR = "RULE_VALIDATION_ERROR";
+export declare const RULE_EXECUTION_ERROR = "RULE_EXECUTION_ERROR";
+export declare const RULE_NOT_FOUND = "RULE_NOT_FOUND";
+export declare enum ErrorSeverity {
+    /** Critical errors that require immediate attention */
+    CRITICAL = "CRITICAL",
+    /** High-impact errors that may affect service functioning */
+    HIGH = "HIGH",
+    /** Medium-impact errors that cause partial degradation */
+    MEDIUM = "MEDIUM",
+    /** Low-impact errors that have minimal or local impact */
+    LOW = "LOW",
+    /** Informational errors that are not problematic */
+    INFO = "INFO"
+}
+export declare enum ErrorCategory {
+    /** Errors related to configuration */
+    CONFIGURATION = "CONFIGURATION",
+    /** Errors related to network connectivity */
+    CONNECTIVITY = "CONNECTIVITY",
+    /** Errors related to authentication/authorization */
+    AUTHENTICATION = "AUTHENTICATION",
+    /** Errors related to data validation */
+    VALIDATION = "VALIDATION",
+    /** Errors related to resource availability */
+    RESOURCE = "RESOURCE",
+    /** Errors related to service operations */
+    OPERATION = "OPERATION",
+    /** Errors related to third-party integrations */
+    INTEGRATION = "INTEGRATION",
+    /** Errors related to security */
+    SECURITY = "SECURITY",
+    /** Errors related to data storage */
+    STORAGE = "STORAGE",
+    /** Errors that don't fit into other categories */
+    OTHER = "OTHER"
+}
+export declare enum ErrorRecoverability {
+    /** Error cannot be automatically recovered from */
+    NON_RECOVERABLE = "NON_RECOVERABLE",
+    /** Error might be recoverable with retry */
+    MAYBE_RECOVERABLE = "MAYBE_RECOVERABLE",
+    /** Error is definitely recoverable with retries */
+    RECOVERABLE = "RECOVERABLE",
+    /** Error is transient and should resolve without action */
+    TRANSIENT = "TRANSIENT"
+}

package/dist_ts/ts/errors/error.codes.js

@@ -0,0 +1,136 @@
+/**
+ * Platform Service Error Codes
+ *
+ * This file contains all error codes used across the platform service.
+ *
+ * Format: PREFIX_ERROR_TYPE
+ * - PREFIX: Component/domain prefix (e.g., EMAIL, MTA, SMS)
+ * - ERROR_TYPE: Specific error type within the domain
+ */
+// General platform errors (PLATFORM_*)
+export const PLATFORM_INITIALIZATION_ERROR = 'PLATFORM_INITIALIZATION_ERROR';
+export const PLATFORM_CONFIGURATION_ERROR = 'PLATFORM_CONFIGURATION_ERROR';
+export const PLATFORM_OPERATION_ERROR = 'PLATFORM_OPERATION_ERROR';
+export const PLATFORM_NOT_IMPLEMENTED = 'PLATFORM_NOT_IMPLEMENTED';
+export const PLATFORM_NOT_SUPPORTED = 'PLATFORM_NOT_SUPPORTED';
+export const PLATFORM_SERVICE_UNAVAILABLE = 'PLATFORM_SERVICE_UNAVAILABLE';
+// Email service errors (EMAIL_*)
+export const EMAIL_SERVICE_ERROR = 'EMAIL_SERVICE_ERROR';
+export const EMAIL_TEMPLATE_ERROR = 'EMAIL_TEMPLATE_ERROR';
+export const EMAIL_VALIDATION_ERROR = 'EMAIL_VALIDATION_ERROR';
+export const EMAIL_SEND_ERROR = 'EMAIL_SEND_ERROR';
+export const EMAIL_RECEIVE_ERROR = 'EMAIL_RECEIVE_ERROR';
+export const EMAIL_ATTACHMENT_ERROR = 'EMAIL_ATTACHMENT_ERROR';
+export const EMAIL_PARSE_ERROR = 'EMAIL_PARSE_ERROR';
+export const EMAIL_RATE_LIMIT_EXCEEDED = 'EMAIL_RATE_LIMIT_EXCEEDED';
+// MTA-specific errors (MTA_*)
+export const MTA_CONNECTION_ERROR = 'MTA_CONNECTION_ERROR';
+export const MTA_AUTHENTICATION_ERROR = 'MTA_AUTHENTICATION_ERROR';
+export const MTA_DELIVERY_ERROR = 'MTA_DELIVERY_ERROR';
+export const MTA_CONFIGURATION_ERROR = 'MTA_CONFIGURATION_ERROR';
+export const MTA_DNS_ERROR = 'MTA_DNS_ERROR';
+export const MTA_TIMEOUT_ERROR = 'MTA_TIMEOUT_ERROR';
+export const MTA_PROTOCOL_ERROR = 'MTA_PROTOCOL_ERROR';
+// Bounce management errors (BOUNCE_*)
+export const BOUNCE_PROCESSING_ERROR = 'BOUNCE_PROCESSING_ERROR';
+export const BOUNCE_STORAGE_ERROR = 'BOUNCE_STORAGE_ERROR';
+export const BOUNCE_CLASSIFICATION_ERROR = 'BOUNCE_CLASSIFICATION_ERROR';
+// Email authentication errors (AUTH_*)
+export const AUTH_SPF_ERROR = 'AUTH_SPF_ERROR';
+export const AUTH_DKIM_ERROR = 'AUTH_DKIM_ERROR';
+export const AUTH_DMARC_ERROR = 'AUTH_DMARC_ERROR';
+export const AUTH_KEY_ERROR = 'AUTH_KEY_ERROR';
+// Content scanning errors (SCAN_*)
+export const SCAN_ANALYSIS_ERROR = 'SCAN_ANALYSIS_ERROR';
+export const SCAN_MALWARE_DETECTED = 'SCAN_MALWARE_DETECTED';
+export const SCAN_PHISHING_DETECTED = 'SCAN_PHISHING_DETECTED';
+export const SCAN_CONTENT_REJECTED = 'SCAN_CONTENT_REJECTED';
+// IP and reputation errors (REPUTATION_*)
+export const REPUTATION_CHECK_ERROR = 'REPUTATION_CHECK_ERROR';
+export const REPUTATION_DATA_ERROR = 'REPUTATION_DATA_ERROR';
+export const REPUTATION_BLOCKLIST_ERROR = 'REPUTATION_BLOCKLIST_ERROR';
+export const REPUTATION_UPDATE_ERROR = 'REPUTATION_UPDATE_ERROR';
+// IP warmup errors (WARMUP_*)
+export const WARMUP_ALLOCATION_ERROR = 'WARMUP_ALLOCATION_ERROR';
+export const WARMUP_LIMIT_EXCEEDED = 'WARMUP_LIMIT_EXCEEDED';
+export const WARMUP_SCHEDULE_ERROR = 'WARMUP_SCHEDULE_ERROR';
+// Network and connectivity errors (NETWORK_*)
+export const NETWORK_CONNECTION_ERROR = 'NETWORK_CONNECTION_ERROR';
+export const NETWORK_TIMEOUT = 'NETWORK_TIMEOUT';
+export const NETWORK_DNS_ERROR = 'NETWORK_DNS_ERROR';
+export const NETWORK_TLS_ERROR = 'NETWORK_TLS_ERROR';
+// Queue and processing errors (QUEUE_*)
+export const QUEUE_FULL_ERROR = 'QUEUE_FULL_ERROR';
+export const QUEUE_PROCESSING_ERROR = 'QUEUE_PROCESSING_ERROR';
+export const QUEUE_PERSISTENCE_ERROR = 'QUEUE_PERSISTENCE_ERROR';
+export const QUEUE_ITEM_NOT_FOUND = 'QUEUE_ITEM_NOT_FOUND';
+// DcRouter errors (DCR_*)
+export const DCR_ROUTING_ERROR = 'DCR_ROUTING_ERROR';
+export const DCR_CONFIGURATION_ERROR = 'DCR_CONFIGURATION_ERROR';
+export const DCR_PROXY_ERROR = 'DCR_PROXY_ERROR';
+export const DCR_DOMAIN_ERROR = 'DCR_DOMAIN_ERROR';
+// SMS service errors (SMS_*)
+export const SMS_SERVICE_ERROR = 'SMS_SERVICE_ERROR';
+export const SMS_SEND_ERROR = 'SMS_SEND_ERROR';
+export const SMS_VALIDATION_ERROR = 'SMS_VALIDATION_ERROR';
+export const SMS_RATE_LIMIT_EXCEEDED = 'SMS_RATE_LIMIT_EXCEEDED';
+// Storage errors (STORAGE_*)
+export const STORAGE_WRITE_ERROR = 'STORAGE_WRITE_ERROR';
+export const STORAGE_READ_ERROR = 'STORAGE_READ_ERROR';
+export const STORAGE_DELETE_ERROR = 'STORAGE_DELETE_ERROR';
+export const STORAGE_QUOTA_EXCEEDED = 'STORAGE_QUOTA_EXCEEDED';
+// Rule management errors (RULE_*)
+export const RULE_VALIDATION_ERROR = 'RULE_VALIDATION_ERROR';
+export const RULE_EXECUTION_ERROR = 'RULE_EXECUTION_ERROR';
+export const RULE_NOT_FOUND = 'RULE_NOT_FOUND';
+// Type definitions for error severity
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    /** Critical errors that require immediate attention */
+    ErrorSeverity["CRITICAL"] = "CRITICAL";
+    /** High-impact errors that may affect service functioning */
+    ErrorSeverity["HIGH"] = "HIGH";
+    /** Medium-impact errors that cause partial degradation */
+    ErrorSeverity["MEDIUM"] = "MEDIUM";
+    /** Low-impact errors that have minimal or local impact */
+    ErrorSeverity["LOW"] = "LOW";
+    /** Informational errors that are not problematic */
+    ErrorSeverity["INFO"] = "INFO";
+})(ErrorSeverity || (ErrorSeverity = {}));
+// Type definitions for error categories
+export var ErrorCategory;
+(function (ErrorCategory) {
+    /** Errors related to configuration */
+    ErrorCategory["CONFIGURATION"] = "CONFIGURATION";
+    /** Errors related to network connectivity */
+    ErrorCategory["CONNECTIVITY"] = "CONNECTIVITY";
+    /** Errors related to authentication/authorization */
+    ErrorCategory["AUTHENTICATION"] = "AUTHENTICATION";
+    /** Errors related to data validation */
+    ErrorCategory["VALIDATION"] = "VALIDATION";
+    /** Errors related to resource availability */
+    ErrorCategory["RESOURCE"] = "RESOURCE";
+    /** Errors related to service operations */
+    ErrorCategory["OPERATION"] = "OPERATION";
+    /** Errors related to third-party integrations */
+    ErrorCategory["INTEGRATION"] = "INTEGRATION";
+    /** Errors related to security */
+    ErrorCategory["SECURITY"] = "SECURITY";
+    /** Errors related to data storage */
+    ErrorCategory["STORAGE"] = "STORAGE";
+    /** Errors that don't fit into other categories */
+    ErrorCategory["OTHER"] = "OTHER";
+})(ErrorCategory || (ErrorCategory = {}));
+// Type definitions for error recoverability
+export var ErrorRecoverability;
+(function (ErrorRecoverability) {
+    /** Error cannot be automatically recovered from */
+    ErrorRecoverability["NON_RECOVERABLE"] = "NON_RECOVERABLE";
+    /** Error might be recoverable with retry */
+    ErrorRecoverability["MAYBE_RECOVERABLE"] = "MAYBE_RECOVERABLE";
+    /** Error is definitely recoverable with retries */
+    ErrorRecoverability["RECOVERABLE"] = "RECOVERABLE";
+    /** Error is transient and should resolve without action */
+    ErrorRecoverability["TRANSIENT"] = "TRANSIENT";
+})(ErrorRecoverability || (ErrorRecoverability = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/errors/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Platform Service Error System
+ *
+ * This module provides a comprehensive error handling system for the Platform Service,
+ * with structured error types, error codes, and consistent patterns for logging and recovery.
+ */
+export * from './error.codes.js';
+export * from './base.errors.js';
+export * from './email.errors.js';
+export * from './mta.errors.js';
+export * from './reputation.errors.js';
+export * from './error-handler.js';
+import { getErrorClassForCategory } from './base.errors.js';
+export { getErrorClassForCategory };
+import { PlatformError } from './base.errors.js';
+/**
+ * Create a typed error from a standard Error
+ * Useful for converting errors from external libraries or APIs
+ *
+ * @param error Standard error to convert
+ * @param code Error code to assign
+ * @param contextData Additional context data
+ * @returns Typed PlatformError
+ */
+export declare function fromError(error: Error, code: string, contextData?: Record<string, any>): PlatformError;
+/**
+ * Determine if an error is retryable
+ *
+ * @param error Error to check
+ * @returns Boolean indicating if the error should be retried
+ */
+export declare function isRetryable(error: any): boolean;
+/**
+ * Create a wrapped version of a function that catches errors
+ * and converts them to typed PlatformErrors
+ *
+ * @param fn Function to wrap
+ * @param errorCode Default error code to use
+ * @param contextData Additional context data
+ * @returns Wrapped function
+ */
+export declare function withErrorHandling<T extends (...args: any[]) => Promise<any>>(fn: T, errorCode: string, contextData?: Record<string, any>): T;
+/**
+ * Retry a function with exponential backoff
+ *
+ * @param fn Function to retry
+ * @param options Retry options
+ * @returns Function result or throws after max retries
+ */
+export declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffFactor?: number;
+    retryableErrors?: Array<string | RegExp>;
+}): Promise<T>;