@serve.zone/dcrouter 11.0.22 → 11.0.25

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

@@ -1,98 +0,0 @@
-import { PlatformError } from './base.errors.js';
-import type { IErrorContext } from './base.errors.js';
-/**
- * Error handler configuration
- */
-export interface IErrorHandlerConfig {
-    /** Whether to log errors automatically */
-    logErrors: boolean;
-    /** Whether to include stack traces in prod environment */
-    includeStacksInProd: boolean;
-    /** Default retry options */
-    retry: {
-        /** Maximum retry attempts */
-        maxAttempts: number;
-        /** Base delay between retries in ms */
-        baseDelay: number;
-        /** Maximum delay between retries in ms */
-        maxDelay: number;
-        /** Backoff factor for exponential backoff */
-        backoffFactor: number;
-    };
-}
-/**
- * Error handler utility
- * Provides methods for consistent error handling across the platform
- */
-export declare class ErrorHandler {
-    /**
-     * Current configuration
-     */
-    static config: IErrorHandlerConfig;
-    /**
-     * Update error handler configuration
-     *
-     * @param newConfig New configuration (partial)
-     */
-    static configure(newConfig: Partial<IErrorHandlerConfig>): void;
-    /**
-     * 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: any, defaultCode: string, context?: IErrorContext): PlatformError;
-    /**
-     * 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: any, includeDetails?: boolean): Record<string, any>;
-    /**
-     * 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: any, defaultCode: string, context?: IErrorContext): Record<string, any>;
-    /**
-     * 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 execute<T>(fn: () => Promise<T>, defaultCode: string, context?: IErrorContext): Promise<T>;
-    /**
-     * 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 executeWithRetry<T>(fn: () => Promise<T>, defaultCode: string, options?: {
-        maxAttempts?: number;
-        baseDelay?: number;
-        maxDelay?: number;
-        backoffFactor?: number;
-        retryableErrorCodes?: string[];
-        retryableErrorPatterns?: RegExp[];
-        onRetry?: (error: PlatformError, attempt: number, delay: number) => void;
-    }, context?: IErrorContext): Promise<T>;
-}
-/**
- * Create a middleware for handling errors in HTTP requests
- *
- * @returns Middleware function
- */
-export declare function createErrorHandlerMiddleware(): (error: any, req: any, res: any, next: any) => void;

package/dist_ts/errors/error-handler.js

@@ -1,282 +0,0 @@
-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 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":"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"}

package/dist_ts/errors/index.d.ts

@@ -1,54 +0,0 @@
-/**
- * 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 './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>;

package/dist_ts/errors/index.js

@@ -1,136 +0,0 @@
-/**
- * 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 error codes and types
-export * from './error.codes.js';
-// Export base error classes
-export * from './base.errors.js';
-// Export domain-specific error classes
-export * from './reputation.errors.js';
-// Export error handler
-export * from './error-handler.js';
-// Export utility function to create specific error types based on the error category
-import { getErrorClassForCategory } from './base.errors.js';
-export { getErrorClassForCategory };
-// Import needed classes for utility functions
-import { PlatformError } from './base.errors.js';
-import { ErrorSeverity, ErrorCategory, ErrorRecoverability } from './error.codes.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 function fromError(error, code, contextData = {}) {
-    return new PlatformError(error.message, code, ErrorSeverity.MEDIUM, ErrorCategory.OPERATION, ErrorRecoverability.NON_RECOVERABLE, {
-        data: {
-            ...contextData,
-            originalError: {
-                name: error.name,
-                message: error.message,
-                stack: error.stack
-            }
-        }
-    });
-}
-/**
- * Determine if an error is retryable
- *
- * @param error Error to check
- * @returns Boolean indicating if the error should be retried
- */
-export function isRetryable(error) {
-    // If it's our platform error, use its recoverability property
-    if (error && typeof error === 'object' && 'recoverability' in error) {
-        return error.recoverability === ErrorRecoverability.RECOVERABLE ||
-            error.recoverability === ErrorRecoverability.MAYBE_RECOVERABLE ||
-            error.recoverability === ErrorRecoverability.TRANSIENT;
-    }
-    // Check if it's a network error (these are often transient)
-    if (error && typeof error === 'object' && error.code) {
-        const networkErrors = [
-            'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EHOSTUNREACH',
-            'ENETUNREACH', 'ENOTFOUND', 'EPROTO', 'ECONNABORTED'
-        ];
-        return networkErrors.includes(error.code);
-    }
-    // By default, we can't determine if the error is retryable
-    return false;
-}
-/**
- * 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 function withErrorHandling(fn, errorCode, contextData = {}) {
-    return (async function (...args) {
-        try {
-            return await fn(...args);
-        }
-        catch (error) {
-            if (error && typeof error === 'object' && 'code' in error) {
-                // Already a typed error, rethrow
-                throw error;
-            }
-            throw fromError(error instanceof Error ? error : new Error(String(error)), errorCode, {
-                ...contextData,
-                fnName: fn.name,
-                args: args.map(arg => typeof arg === 'object'
-                    ? '[Object]'
-                    : String(arg).substring(0, 100))
-            });
-        }
-    });
-}
-/**
- * Retry a function with exponential backoff
- *
- * @param fn Function to retry
- * @param options Retry options
- * @returns Function result or throws after max retries
- */
-export async function retry(fn, options = {}) {
-    const { maxRetries = 3, initialDelay = 1000, maxDelay = 30000, backoffFactor = 2, retryableErrors = [] } = options;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error instanceof Error
-                ? error
-                : new Error(String(error));
-            // Check if we should retry
-            const shouldRetry = attempt < maxRetries && (isRetryable(error) ||
-                retryableErrors.some(pattern => {
-                    if (typeof pattern === 'string') {
-                        return lastError.message.includes(pattern);
-                    }
-                    return pattern.test(lastError.message);
-                }));
-            if (!shouldRetry) {
-                throw lastError;
-            }
-            // Calculate delay with exponential backoff
-            const delay = Math.min(initialDelay * 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);
-            // Wait before next retry
-            await new Promise(resolve => setTimeout(resolve, actualDelay));
-        }
-    }
-    // This should never happen, but TypeScript needs it
-    throw lastError;
-}
-//# sourceMappingURL=data:application/json;base64,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