@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/cjs/nestjs-config-aws/src/integration/services/error-handler.service.js

@@ -0,0 +1,267 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ErrorHandlerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandlerService = void 0;
+const common_1 = require("@nestjs/common");
+const config_aws_1 = require("@dyanet/config-aws");
+/**
+ * Service for handling errors and implementing graceful degradation strategies
+ * in the AWS configuration integration.
+ */
+let ErrorHandlerService = ErrorHandlerService_1 = class ErrorHandlerService {
+    options;
+    logger = new common_1.Logger(ErrorHandlerService_1.name);
+    errorHandling;
+    constructor(options) {
+        this.options = options;
+        // Set default error handling strategy
+        this.errorHandling = {
+            onAwsUnavailable: 'warn',
+            onConfigurationError: 'warn',
+            onValidationError: 'fail',
+            enableDetailedLogging: true,
+            ...options.errorHandling,
+        };
+    }
+    /**
+     * Handle AWS service unavailability.
+     * @param serviceName - Name of the AWS service that's unavailable
+     * @param error - The error that occurred
+     * @returns Whether to continue processing
+     */
+    handleAwsUnavailable(serviceName, error) {
+        const message = `AWS service '${serviceName}' is unavailable${error ? `: ${error.message}` : ''}`;
+        switch (this.errorHandling.onAwsUnavailable) {
+            case 'fail':
+                this.logger.error(message);
+                throw new config_aws_1.ConfigurationError(`AWS service unavailable: ${serviceName}`, error);
+            case 'warn':
+                this.logger.warn(message);
+                this.logger.warn('Continuing with available configuration sources');
+                return true;
+            case 'silent':
+                if (this.errorHandling.enableDetailedLogging) {
+                    this.logger.debug(message);
+                }
+                return true;
+            default:
+                this.logger.warn(message);
+                return true;
+        }
+    }
+    /**
+     * Handle configuration loading errors.
+     * @param source - Name of the configuration source
+     * @param error - The error that occurred
+     * @returns Whether to continue processing
+     */
+    handleConfigurationError(source, error) {
+        const message = `Configuration error from '${source}': ${error.message}`;
+        switch (this.errorHandling.onConfigurationError) {
+            case 'fail':
+                this.logger.error(message);
+                throw new config_aws_1.ConfigurationError(`Configuration loading failed: ${source}`, error);
+            case 'warn':
+                this.logger.warn(message);
+                this.logger.warn('Continuing with other configuration sources');
+                return true;
+            case 'use-default':
+                this.logger.warn(message);
+                this.logger.warn('Using default configuration values');
+                return true;
+            default:
+                this.logger.warn(message);
+                return true;
+        }
+    }
+    /**
+     * Handle validation errors.
+     * @param field - The field that failed validation
+     * @param error - The validation error
+     * @returns Whether to continue processing
+     */
+    handleValidationError(field, error) {
+        const message = `Validation error for field '${field}': ${error.message}`;
+        switch (this.errorHandling.onValidationError) {
+            case 'fail':
+                this.logger.error(message);
+                throw new config_aws_1.ConfigurationError(`Validation failed: ${field}`, error);
+            case 'warn':
+                this.logger.warn(message);
+                this.logger.warn('Continuing with invalid configuration value');
+                return true;
+            case 'skip-invalid':
+                this.logger.warn(message);
+                this.logger.warn('Skipping invalid configuration value');
+                return false;
+            default:
+                this.logger.error(message);
+                throw new config_aws_1.ConfigurationError(`Validation failed: ${field}`, error);
+        }
+    }
+    /**
+     * Handle network connectivity issues.
+     * @param service - The service experiencing connectivity issues
+     * @param error - The network error
+     * @returns Whether to retry or continue
+     */
+    handleNetworkError(service, error) {
+        const message = `Network error connecting to '${service}': ${error.message}`;
+        if (this.errorHandling.enableDetailedLogging) {
+            this.logger.error(message);
+            this.logger.error('Stack trace:', error.stack);
+        }
+        else {
+            this.logger.error(message);
+        }
+        // For network errors, we generally don't retry immediately but continue with other sources
+        return {
+            shouldRetry: false,
+            shouldContinue: true,
+        };
+    }
+    /**
+     * Handle permission denied errors.
+     * @param service - The service that denied access
+     * @param resource - The resource that was accessed
+     * @param error - The permission error
+     * @returns Whether to continue processing
+     */
+    handlePermissionError(service, resource, error) {
+        const message = `Permission denied accessing '${resource}' in '${service}': ${error.message}`;
+        this.logger.error(message);
+        this.logger.error('Please check AWS credentials and IAM permissions');
+        if (this.errorHandling.enableDetailedLogging) {
+            this.logger.error('Stack trace:', error.stack);
+        }
+        // Permission errors are usually configuration issues, so we continue with other sources
+        return this.handleConfigurationError(service, error);
+    }
+    /**
+     * Handle resource not found errors.
+     * @param service - The service where the resource was not found
+     * @param resource - The resource that was not found
+     * @param error - The not found error
+     * @returns Whether to continue processing
+     */
+    handleResourceNotFound(service, resource, error) {
+        const message = `Resource '${resource}' not found in '${service}'${error ? `: ${error.message}` : ''}`;
+        if (this.errorHandling.enableDetailedLogging) {
+            this.logger.debug(message);
+            this.logger.debug('This may be expected if the resource is not configured for this environment');
+        }
+        // Resource not found is often expected in different environments
+        return true;
+    }
+    /**
+     * Log detailed error information for troubleshooting.
+     * @param context - The context where the error occurred
+     * @param error - The error to log
+     * @param additionalInfo - Additional information to include
+     */
+    logDetailedError(context, error, additionalInfo) {
+        if (!this.errorHandling.enableDetailedLogging) {
+            return;
+        }
+        this.logger.error(`Detailed error in ${context}:`);
+        this.logger.error(`Error name: ${error.name}`);
+        this.logger.error(`Error message: ${error.message}`);
+        if (error.stack) {
+            this.logger.error(`Stack trace: ${error.stack}`);
+        }
+        if (additionalInfo) {
+            this.logger.error(`Additional info: ${JSON.stringify(additionalInfo, null, 2)}`);
+        }
+        // Log environment information that might be relevant
+        this.logger.error('Environment context:');
+        this.logger.error(`NODE_ENV: ${process.env['NODE_ENV'] || 'undefined'}`);
+        this.logger.error(`APP_ENV: ${process.env['APP_ENV'] || 'undefined'}`);
+        this.logger.error(`AWS_REGION: ${process.env['AWS_REGION'] || 'undefined'}`);
+        this.logger.error(`AWS_PROFILE: ${process.env['AWS_PROFILE'] || 'undefined'}`);
+    }
+    /**
+     * Create a fallback configuration when AWS sources fail.
+     * @param namespace - Optional namespace for the fallback config
+     * @returns Fallback configuration object
+     */
+    createFallbackConfiguration(namespace) {
+        const fallbackConfig = {};
+        if (this.options.fallbackToLocal) {
+            this.logger.warn('Creating fallback configuration from environment variables');
+            // Extract environment variables that might be configuration
+            for (const [key, value] of Object.entries(process.env)) {
+                if (value !== undefined) {
+                    // If namespace is specified, only include keys that match
+                    if (namespace) {
+                        const upperNamespace = namespace.toUpperCase();
+                        if (key.toUpperCase().startsWith(upperNamespace)) {
+                            const namespacedKey = key.substring(namespace.length);
+                            const cleanKey = namespacedKey.startsWith('_') ? namespacedKey.substring(1) : namespacedKey;
+                            if (cleanKey) {
+                                fallbackConfig[cleanKey] = value;
+                            }
+                        }
+                    }
+                    else {
+                        fallbackConfig[key] = value;
+                    }
+                }
+            }
+        }
+        return fallbackConfig;
+    }
+    /**
+     * Check if an error is retryable.
+     * @param error - The error to check
+     * @returns Whether the error is retryable
+     */
+    isRetryableError(error) {
+        // Network errors are generally retryable
+        if (error.name === 'NetworkingError' || error.name === 'TimeoutError') {
+            return true;
+        }
+        // Throttling errors are retryable
+        if (error.name === 'ThrottlingException' || error.name === 'TooManyRequestsException') {
+            return true;
+        }
+        // Service unavailable errors are retryable
+        if (error.name === 'ServiceUnavailableException') {
+            return true;
+        }
+        // Permission and resource not found errors are not retryable
+        if (error.name === 'AccessDeniedException' || error.name === 'ResourceNotFoundException') {
+            return false;
+        }
+        // Default to not retryable for unknown errors
+        return false;
+    }
+    /**
+     * Get retry delay for retryable errors.
+     * @param attemptNumber - The current attempt number (1-based)
+     * @returns Delay in milliseconds
+     */
+    getRetryDelay(attemptNumber) {
+        // Exponential backoff with jitter
+        const baseDelay = 1000; // 1 second
+        const maxDelay = 30000; // 30 seconds
+        const delay = Math.min(baseDelay * Math.pow(2, attemptNumber - 1), maxDelay);
+        // Add jitter (±25%)
+        const jitter = delay * 0.25 * (Math.random() - 0.5);
+        return Math.max(100, delay + jitter); // Minimum 100ms delay
+    }
+};
+exports.ErrorHandlerService = ErrorHandlerService;
+exports.ErrorHandlerService = ErrorHandlerService = ErrorHandlerService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], ErrorHandlerService);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.service.js","sourceRoot":"","sources":["../../../../../../src/integration/services/error-handler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\r\nimport { ConfigurationError } from '@dyanet/config-aws';\r\nimport { IntegrationOptions, ErrorHandlingStrategy } from '../interfaces/integration-options.interface';\r\n\r\n/**\r\n * Service for handling errors and implementing graceful degradation strategies\r\n * in the AWS configuration integration.\r\n */\r\n@Injectable()\r\nexport class ErrorHandlerService {\r\n  private readonly logger = new Logger(ErrorHandlerService.name);\r\n  private readonly errorHandling: ErrorHandlingStrategy;\r\n\r\n  constructor(private readonly options: IntegrationOptions) {\r\n    // Set default error handling strategy\r\n    this.errorHandling = {\r\n      onAwsUnavailable: 'warn',\r\n      onConfigurationError: 'warn',\r\n      onValidationError: 'fail',\r\n      enableDetailedLogging: true,\r\n      ...options.errorHandling,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Handle AWS service unavailability.\r\n   * @param serviceName - Name of the AWS service that's unavailable\r\n   * @param error - The error that occurred\r\n   * @returns Whether to continue processing\r\n   */\r\n  handleAwsUnavailable(serviceName: string, error?: Error): boolean {\r\n    const message = `AWS service '${serviceName}' is unavailable${error ? `: ${error.message}` : ''}`;\r\n\r\n    switch (this.errorHandling.onAwsUnavailable) {\r\n      case 'fail':\r\n        this.logger.error(message);\r\n        throw new ConfigurationError(`AWS service unavailable: ${serviceName}`, error);\r\n      \r\n      case 'warn':\r\n        this.logger.warn(message);\r\n        this.logger.warn('Continuing with available configuration sources');\r\n        return true;\r\n      \r\n      case 'silent':\r\n        if (this.errorHandling.enableDetailedLogging) {\r\n          this.logger.debug(message);\r\n        }\r\n        return true;\r\n      \r\n      default:\r\n        this.logger.warn(message);\r\n        return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle configuration loading errors.\r\n   * @param source - Name of the configuration source\r\n   * @param error - The error that occurred\r\n   * @returns Whether to continue processing\r\n   */\r\n  handleConfigurationError(source: string, error: Error): boolean {\r\n    const message = `Configuration error from '${source}': ${error.message}`;\r\n\r\n    switch (this.errorHandling.onConfigurationError) {\r\n      case 'fail':\r\n        this.logger.error(message);\r\n        throw new ConfigurationError(`Configuration loading failed: ${source}`, error);\r\n      \r\n      case 'warn':\r\n        this.logger.warn(message);\r\n        this.logger.warn('Continuing with other configuration sources');\r\n        return true;\r\n      \r\n      case 'use-default':\r\n        this.logger.warn(message);\r\n        this.logger.warn('Using default configuration values');\r\n        return true;\r\n      \r\n      default:\r\n        this.logger.warn(message);\r\n        return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle validation errors.\r\n   * @param field - The field that failed validation\r\n   * @param error - The validation error\r\n   * @returns Whether to continue processing\r\n   */\r\n  handleValidationError(field: string, error: Error): boolean {\r\n    const message = `Validation error for field '${field}': ${error.message}`;\r\n\r\n    switch (this.errorHandling.onValidationError) {\r\n      case 'fail':\r\n        this.logger.error(message);\r\n        throw new ConfigurationError(`Validation failed: ${field}`, error);\r\n      \r\n      case 'warn':\r\n        this.logger.warn(message);\r\n        this.logger.warn('Continuing with invalid configuration value');\r\n        return true;\r\n      \r\n      case 'skip-invalid':\r\n        this.logger.warn(message);\r\n        this.logger.warn('Skipping invalid configuration value');\r\n        return false;\r\n      \r\n      default:\r\n        this.logger.error(message);\r\n        throw new ConfigurationError(`Validation failed: ${field}`, error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle network connectivity issues.\r\n   * @param service - The service experiencing connectivity issues\r\n   * @param error - The network error\r\n   * @returns Whether to retry or continue\r\n   */\r\n  handleNetworkError(service: string, error: Error): { shouldRetry: boolean; shouldContinue: boolean } {\r\n    const message = `Network error connecting to '${service}': ${error.message}`;\r\n\r\n    if (this.errorHandling.enableDetailedLogging) {\r\n      this.logger.error(message);\r\n      this.logger.error('Stack trace:', error.stack);\r\n    } else {\r\n      this.logger.error(message);\r\n    }\r\n\r\n    // For network errors, we generally don't retry immediately but continue with other sources\r\n    return {\r\n      shouldRetry: false,\r\n      shouldContinue: true,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Handle permission denied errors.\r\n   * @param service - The service that denied access\r\n   * @param resource - The resource that was accessed\r\n   * @param error - The permission error\r\n   * @returns Whether to continue processing\r\n   */\r\n  handlePermissionError(service: string, resource: string, error: Error): boolean {\r\n    const message = `Permission denied accessing '${resource}' in '${service}': ${error.message}`;\r\n    \r\n    this.logger.error(message);\r\n    this.logger.error('Please check AWS credentials and IAM permissions');\r\n\r\n    if (this.errorHandling.enableDetailedLogging) {\r\n      this.logger.error('Stack trace:', error.stack);\r\n    }\r\n\r\n    // Permission errors are usually configuration issues, so we continue with other sources\r\n    return this.handleConfigurationError(service, error);\r\n  }\r\n\r\n  /**\r\n   * Handle resource not found errors.\r\n   * @param service - The service where the resource was not found\r\n   * @param resource - The resource that was not found\r\n   * @param error - The not found error\r\n   * @returns Whether to continue processing\r\n   */\r\n  handleResourceNotFound(service: string, resource: string, error?: Error): boolean {\r\n    const message = `Resource '${resource}' not found in '${service}'${error ? `: ${error.message}` : ''}`;\r\n    \r\n    if (this.errorHandling.enableDetailedLogging) {\r\n      this.logger.debug(message);\r\n      this.logger.debug('This may be expected if the resource is not configured for this environment');\r\n    }\r\n\r\n    // Resource not found is often expected in different environments\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Log detailed error information for troubleshooting.\r\n   * @param context - The context where the error occurred\r\n   * @param error - The error to log\r\n   * @param additionalInfo - Additional information to include\r\n   */\r\n  logDetailedError(context: string, error: Error, additionalInfo?: Record<string, any>): void {\r\n    if (!this.errorHandling.enableDetailedLogging) {\r\n      return;\r\n    }\r\n\r\n    this.logger.error(`Detailed error in ${context}:`);\r\n    this.logger.error(`Error name: ${error.name}`);\r\n    this.logger.error(`Error message: ${error.message}`);\r\n    \r\n    if (error.stack) {\r\n      this.logger.error(`Stack trace: ${error.stack}`);\r\n    }\r\n\r\n    if (additionalInfo) {\r\n      this.logger.error(`Additional info: ${JSON.stringify(additionalInfo, null, 2)}`);\r\n    }\r\n\r\n    // Log environment information that might be relevant\r\n    this.logger.error('Environment context:');\r\n    this.logger.error(`NODE_ENV: ${process.env['NODE_ENV'] || 'undefined'}`);\r\n    this.logger.error(`APP_ENV: ${process.env['APP_ENV'] || 'undefined'}`);\r\n    this.logger.error(`AWS_REGION: ${process.env['AWS_REGION'] || 'undefined'}`);\r\n    this.logger.error(`AWS_PROFILE: ${process.env['AWS_PROFILE'] || 'undefined'}`);\r\n  }\r\n\r\n  /**\r\n   * Create a fallback configuration when AWS sources fail.\r\n   * @param namespace - Optional namespace for the fallback config\r\n   * @returns Fallback configuration object\r\n   */\r\n  createFallbackConfiguration(namespace?: string): Record<string, any> {\r\n    const fallbackConfig: Record<string, any> = {};\r\n\r\n    if (this.options.fallbackToLocal) {\r\n      this.logger.warn('Creating fallback configuration from environment variables');\r\n      \r\n      // Extract environment variables that might be configuration\r\n      for (const [key, value] of Object.entries(process.env)) {\r\n        if (value !== undefined) {\r\n          // If namespace is specified, only include keys that match\r\n          if (namespace) {\r\n            const upperNamespace = namespace.toUpperCase();\r\n            if (key.toUpperCase().startsWith(upperNamespace)) {\r\n              const namespacedKey = key.substring(namespace.length);\r\n              const cleanKey = namespacedKey.startsWith('_') ? namespacedKey.substring(1) : namespacedKey;\r\n              if (cleanKey) {\r\n                fallbackConfig[cleanKey] = value;\r\n              }\r\n            }\r\n          } else {\r\n            fallbackConfig[key] = value;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return fallbackConfig;\r\n  }\r\n\r\n  /**\r\n   * Check if an error is retryable.\r\n   * @param error - The error to check\r\n   * @returns Whether the error is retryable\r\n   */\r\n  isRetryableError(error: Error): boolean {\r\n    // Network errors are generally retryable\r\n    if (error.name === 'NetworkingError' || error.name === 'TimeoutError') {\r\n      return true;\r\n    }\r\n\r\n    // Throttling errors are retryable\r\n    if (error.name === 'ThrottlingException' || error.name === 'TooManyRequestsException') {\r\n      return true;\r\n    }\r\n\r\n    // Service unavailable errors are retryable\r\n    if (error.name === 'ServiceUnavailableException') {\r\n      return true;\r\n    }\r\n\r\n    // Permission and resource not found errors are not retryable\r\n    if (error.name === 'AccessDeniedException' || error.name === 'ResourceNotFoundException') {\r\n      return false;\r\n    }\r\n\r\n    // Default to not retryable for unknown errors\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Get retry delay for retryable errors.\r\n   * @param attemptNumber - The current attempt number (1-based)\r\n   * @returns Delay in milliseconds\r\n   */\r\n  getRetryDelay(attemptNumber: number): number {\r\n    // Exponential backoff with jitter\r\n    const baseDelay = 1000; // 1 second\r\n    const maxDelay = 30000; // 30 seconds\r\n    \r\n    const delay = Math.min(baseDelay * Math.pow(2, attemptNumber - 1), maxDelay);\r\n    \r\n    // Add jitter (±25%)\r\n    const jitter = delay * 0.25 * (Math.random() - 0.5);\r\n    \r\n    return Math.max(100, delay + jitter); // Minimum 100ms delay\r\n  }\r\n}"]}