@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/nestjs-config-aws/src/integration/providers/aws-configuration-loader.service.js

@@ -0,0 +1,589 @@
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var AwsConfigurationLoaderService_1;
+import { Injectable, Logger, Inject, Optional } from '@nestjs/common';
+import { SecretsManagerLoader, SSMParameterStoreLoader, EnvironmentLoader, } from '@dyanet/config-aws';
+import { ErrorHandlerService } from '../services/error-handler.service';
+/**
+ * Service for loading configuration from AWS sources for integration with @nestjs/config.
+ * Uses existing AWS loaders to fetch configuration and provides namespace-aware loading capabilities.
+ */
+let AwsConfigurationLoaderService = AwsConfigurationLoaderService_1 = class AwsConfigurationLoaderService {
+    logger = new Logger(AwsConfigurationLoaderService_1.name);
+    loaders;
+    options;
+    errorHandler;
+    constructor(options) {
+        this.options = options || {};
+        this.errorHandler = new ErrorHandlerService(this.options);
+        this.loaders = this.createLoaders();
+    }
+    /**
+     * Load configuration from AWS sources.
+     * @returns Promise resolving to configuration data
+     */
+    async loadConfiguration() {
+        const mergedConfig = {};
+        const sources = [];
+        for (const loader of this.loaders) {
+            try {
+                // Check if loader is available in current environment with timeout
+                const isAvailable = await this.checkAvailabilityWithTimeout(loader);
+                if (!isAvailable) {
+                    if (this.options.enableLogging) {
+                        this.logger.debug(`Skipping ${loader.getName()} - not available in current environment`);
+                    }
+                    continue;
+                }
+                if (this.options.enableLogging) {
+                    this.logger.debug(`Loading configuration from ${loader.getName()}`);
+                }
+                // Load configuration from this source with retry logic for AWS services
+                const loaderConfig = loader instanceof EnvironmentLoader
+                    ? await loader.load()
+                    : await this.loadWithRetry(loader);
+                // Create configuration source metadata
+                const source = {
+                    name: loader.getName(),
+                    type: this.getSourceType(loader),
+                    priority: this.getSourcePriority(loader),
+                    data: loaderConfig,
+                    loadedAt: new Date(),
+                };
+                sources.push(source);
+                // Merge with existing configuration based on precedence
+                Object.assign(mergedConfig, loaderConfig);
+                if (this.options.enableLogging) {
+                    const keyCount = Object.keys(loaderConfig).length;
+                    this.logger.debug(`Loaded ${keyCount} configuration values from ${loader.getName()}`);
+                }
+            }
+            catch (error) {
+                const loaderError = error instanceof Error ? error : new Error(String(error));
+                // Log detailed error information for troubleshooting
+                this.errorHandler.logDetailedError(`loadConfiguration - ${loader.getName()}`, loaderError, {
+                    loaderName: loader.getName(),
+                    loaderType: this.getSourceType(loader),
+                });
+                // Handle specific error types
+                if (this.isAwsServiceError(loaderError)) {
+                    const shouldContinue = this.handleAwsSpecificError(loader, loaderError);
+                    if (!shouldContinue) {
+                        throw loaderError;
+                    }
+                }
+                else {
+                    // Handle general configuration errors
+                    const shouldContinue = this.errorHandler.handleConfigurationError(loader.getName(), loaderError);
+                    if (!shouldContinue) {
+                        throw loaderError;
+                    }
+                }
+                // Add error to source metadata
+                const errorSource = {
+                    name: loader.getName(),
+                    type: this.getSourceType(loader),
+                    priority: this.getSourcePriority(loader),
+                    data: {},
+                    loadedAt: new Date(),
+                    errors: [loaderError.message],
+                };
+                sources.push(errorSource);
+            }
+        }
+        return mergedConfig;
+    }
+    /**
+     * Load configuration for specific namespaces from AWS sources.
+     * @param namespaces - Array of namespace names to load
+     * @returns Promise resolving to namespaced configuration data
+     */
+    async loadNamespacedConfiguration(namespaces) {
+        const result = {};
+        // Initialize all namespaces
+        for (const namespace of namespaces) {
+            result[namespace] = {};
+        }
+        for (const loader of this.loaders) {
+            try {
+                // Check if loader is available in current environment with timeout
+                const isAvailable = await this.checkAvailabilityWithTimeout(loader);
+                if (!isAvailable) {
+                    if (this.options.enableLogging) {
+                        this.logger.debug(`Skipping ${loader.getName()} for namespace loading - not available`);
+                    }
+                    continue;
+                }
+                if (this.options.enableLogging) {
+                    this.logger.debug(`Loading namespaced configuration from ${loader.getName()}`);
+                }
+                // Load configuration from this source with retry logic for AWS services
+                const loaderConfig = loader instanceof EnvironmentLoader
+                    ? await loader.load()
+                    : await this.loadWithRetry(loader);
+                // Distribute configuration to namespaces based on key prefixes or patterns
+                for (const namespace of namespaces) {
+                    const namespacedConfig = this.extractNamespaceConfig(loaderConfig, namespace);
+                    if (Object.keys(namespacedConfig).length > 0) {
+                        Object.assign(result[namespace], namespacedConfig);
+                        if (this.options.enableLogging) {
+                            const keyCount = Object.keys(namespacedConfig).length;
+                            this.logger.debug(`Loaded ${keyCount} values for namespace '${namespace}' from ${loader.getName()}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const loaderError = error instanceof Error ? error : new Error(String(error));
+                // Log detailed error information for troubleshooting
+                this.errorHandler.logDetailedError(`loadNamespacedConfiguration - ${loader.getName()}`, loaderError, {
+                    loaderName: loader.getName(),
+                    loaderType: this.getSourceType(loader),
+                    namespaces,
+                });
+                // Handle specific error types
+                if (this.isAwsServiceError(loaderError)) {
+                    const shouldContinue = this.handleAwsSpecificError(loader, loaderError);
+                    if (!shouldContinue) {
+                        throw loaderError;
+                    }
+                }
+                else {
+                    // Handle general configuration errors
+                    const shouldContinue = this.errorHandler.handleConfigurationError(loader.getName(), loaderError);
+                    if (!shouldContinue) {
+                        throw loaderError;
+                    }
+                }
+                // Create fallback configuration for each namespace
+                if (this.options.fallbackToLocal) {
+                    for (const namespace of namespaces) {
+                        const fallbackConfig = this.errorHandler.createFallbackConfiguration(namespace);
+                        Object.assign(result[namespace], fallbackConfig);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if AWS services are available.
+     * @returns Promise resolving to availability status
+     */
+    async isAvailable() {
+        try {
+            // Check if at least one AWS loader is available
+            const availabilityChecks = this.loaders
+                .filter(loader => !(loader instanceof EnvironmentLoader)) // Skip environment loader
+                .map(loader => this.checkAvailabilityWithTimeout(loader));
+            if (availabilityChecks.length === 0) {
+                // No AWS loaders configured
+                return false;
+            }
+            // Wait for all availability checks to complete
+            const results = await Promise.allSettled(availabilityChecks);
+            // Return true if at least one AWS service is available
+            return results.some(result => result.status === 'fulfilled' && result.value === true);
+        }
+        catch (error) {
+            const availabilityError = error instanceof Error ? error : new Error(String(error));
+            this.errorHandler.logDetailedError('isAvailable', availabilityError);
+            // Handle as AWS unavailable
+            this.errorHandler.handleAwsUnavailable('AWS Services', availabilityError);
+            return false;
+        }
+    }
+    /**
+     * Get all available configuration sources with their metadata.
+     * @returns Promise resolving to array of configuration sources
+     */
+    async getAvailableSources() {
+        const sources = [];
+        for (const loader of this.loaders) {
+            try {
+                const isAvailable = await loader.isAvailable();
+                if (isAvailable) {
+                    const loaderConfig = await loader.load();
+                    const source = {
+                        name: loader.getName(),
+                        type: this.getSourceType(loader),
+                        priority: this.getSourcePriority(loader),
+                        data: loaderConfig,
+                        loadedAt: new Date(),
+                    };
+                    sources.push(source);
+                }
+            }
+            catch (error) {
+                // Add source with error information
+                const source = {
+                    name: loader.getName(),
+                    type: this.getSourceType(loader),
+                    priority: this.getSourcePriority(loader),
+                    data: {},
+                    loadedAt: new Date(),
+                    errors: [error instanceof Error ? error.message : String(error)],
+                };
+                sources.push(source);
+            }
+        }
+        return sources;
+    }
+    /**
+     * Create configuration loaders based on integration options.
+     * @returns Array of configuration loaders
+     */
+    createLoaders() {
+        const loaders = [];
+        // Always include environment loader
+        loaders.push(new EnvironmentLoader({ prefix: this.options.envPrefix }));
+        // Add AWS Secrets Manager loader if configured
+        if (this.options.secretsManagerConfig?.enabled !== false) {
+            const secretsConfig = {
+                region: this.options.secretsManagerConfig?.region,
+                // Convert paths to secretName format expected by SecretsManagerLoader
+                secretName: this.getSecretsManagerPath(),
+            };
+            loaders.push(new SecretsManagerLoader(secretsConfig));
+        }
+        // Add SSM Parameter Store loader if configured
+        if (this.options.ssmConfig?.enabled !== false) {
+            const ssmConfig = {
+                region: this.options.ssmConfig?.region,
+                // Convert paths to parameterPath format expected by SSMParameterStoreLoader
+                parameterPath: this.getSSMParameterPath(),
+                withDecryption: this.options.ssmConfig?.decrypt ?? true,
+            };
+            loaders.push(new SSMParameterStoreLoader(ssmConfig));
+        }
+        return loaders;
+    }
+    /**
+     * Get the source type for a given loader.
+     * @param loader - The configuration loader
+     * @returns The configuration source type
+     */
+    getSourceType(loader) {
+        if (loader instanceof EnvironmentLoader) {
+            return 'environment';
+        }
+        else if (loader instanceof SecretsManagerLoader) {
+            return 'secrets-manager';
+        }
+        else if (loader instanceof SSMParameterStoreLoader) {
+            return 'ssm';
+        }
+        else {
+            return 'local-file';
+        }
+    }
+    /**
+     * Get the priority for a given loader based on precedence rules.
+     * @param loader - The configuration loader
+     * @returns The priority number (higher = higher priority)
+     */
+    getSourcePriority(loader) {
+        const precedence = this.options.precedence || 'aws-first';
+        if (precedence === 'local-first') {
+            // Environment variables have highest priority
+            if (loader instanceof EnvironmentLoader)
+                return 100;
+            if (loader instanceof SecretsManagerLoader)
+                return 50;
+            if (loader instanceof SSMParameterStoreLoader)
+                return 40;
+        }
+        else if (precedence === 'aws-first') {
+            // AWS sources have higher priority
+            if (loader instanceof SecretsManagerLoader)
+                return 100;
+            if (loader instanceof SSMParameterStoreLoader)
+                return 90;
+            if (loader instanceof EnvironmentLoader)
+                return 50;
+        }
+        else {
+            // merge - equal priority, order matters
+            return 50;
+        }
+        return 50;
+    }
+    /**
+     * Extract configuration for a specific namespace from loaded configuration.
+     * @param config - The loaded configuration
+     * @param namespace - The namespace to extract
+     * @returns Configuration values for the namespace
+     */
+    extractNamespaceConfig(config, namespace) {
+        const namespaceConfig = {};
+        const namespacePrefix = namespace.toUpperCase();
+        // Strategy 1: Look for direct namespace key (e.g., config.database)
+        if (config[namespace]) {
+            Object.assign(namespaceConfig, config[namespace]);
+        }
+        // Strategy 2: Look for keys that start with the namespace prefix (e.g., DATABASE_HOST)
+        for (const [key, value] of Object.entries(config)) {
+            const upperKey = key.toUpperCase();
+            // Check if key starts with namespace prefix followed by underscore
+            if (upperKey.startsWith(`${namespacePrefix}_`)) {
+                // Remove namespace prefix and underscore, convert to camelCase
+                const namespacedKey = key.substring(namespace.length + 1);
+                const camelCaseKey = this.toCamelCase(namespacedKey);
+                if (camelCaseKey) {
+                    namespaceConfig[camelCaseKey] = value;
+                }
+            }
+        }
+        // Strategy 3: Look for nested namespace paths (e.g., /app/database/host)
+        const nestedConfig = this.extractNestedNamespaceConfig(config, namespace);
+        Object.assign(namespaceConfig, nestedConfig);
+        return namespaceConfig;
+    }
+    /**
+     * Extract nested namespace configuration from hierarchical keys.
+     * @param config - The loaded configuration
+     * @param namespace - The namespace to extract
+     * @returns Configuration values for the namespace
+     */
+    extractNestedNamespaceConfig(config, namespace) {
+        const namespaceConfig = {};
+        const namespacePath = `/${namespace}/`;
+        for (const [key, value] of Object.entries(config)) {
+            // Check if key contains namespace path
+            if (key.includes(namespacePath)) {
+                // Extract the part after the namespace path
+                const pathIndex = key.indexOf(namespacePath);
+                const afterNamespace = key.substring(pathIndex + namespacePath.length);
+                if (afterNamespace) {
+                    // Convert path segments to nested object structure
+                    const nestedKey = this.pathToNestedKey(afterNamespace);
+                    this.setNestedValue(namespaceConfig, nestedKey, value);
+                }
+            }
+        }
+        return namespaceConfig;
+    }
+    /**
+     * Convert snake_case or kebab-case to camelCase.
+     * @param str - String to convert
+     * @returns camelCase string
+     */
+    toCamelCase(str) {
+        return str
+            .toLowerCase()
+            .replace(/[_-](.)/g, (_, char) => char.toUpperCase());
+    }
+    /**
+     * Convert path segments to nested key structure.
+     * @param path - Path string (e.g., "host/port")
+     * @returns Nested key structure
+     */
+    pathToNestedKey(path) {
+        return path
+            .split('/')
+            .map(segment => this.toCamelCase(segment))
+            .join('.');
+    }
+    /**
+     * Set a nested value in an object using dot notation.
+     * @param obj - Target object
+     * @param path - Dot notation path
+     * @param value - Value to set
+     */
+    setNestedValue(obj, path, value) {
+        const keys = path.split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            if (key && (!(key in current) || typeof current[key] !== 'object')) {
+                current[key] = {};
+            }
+            if (key) {
+                current = current[key];
+            }
+        }
+        const lastKey = keys[keys.length - 1];
+        if (lastKey) {
+            current[lastKey] = value;
+        }
+    }
+    /**
+     * Get the Secrets Manager path based on configuration.
+     * @returns The secrets manager path
+     */
+    getSecretsManagerPath() {
+        const paths = this.options.secretsManagerConfig?.paths;
+        if (!paths) {
+            return '/nestjs-config-aws';
+        }
+        // Use the first available path or default
+        return paths.production || paths.development || paths.test || '/nestjs-config-aws';
+    }
+    /**
+     * Get the SSM Parameter Store path based on configuration.
+     * @returns The SSM parameter path
+     */
+    getSSMParameterPath() {
+        const paths = this.options.ssmConfig?.paths;
+        if (!paths) {
+            return '/nestjs-config-aws';
+        }
+        // Use the first available path or default
+        return paths.production || paths.development || paths.test || '/nestjs-config-aws';
+    }
+    /**
+     * Check if an error is an AWS service error.
+     * @param error - The error to check
+     * @returns Whether the error is from an AWS service
+     */
+    isAwsServiceError(error) {
+        // AWS SDK errors typically have specific names
+        const awsErrorNames = [
+            'AccessDeniedException',
+            'ResourceNotFoundException',
+            'InvalidRequestException',
+            'ThrottlingException',
+            'ServiceUnavailableException',
+            'NetworkingError',
+            'TimeoutError',
+            'CredentialsError',
+            'UnknownEndpoint',
+        ];
+        return awsErrorNames.includes(error.name) || error.message.includes('AWS');
+    }
+    /**
+     * Handle AWS-specific errors with appropriate strategies.
+     * @param loader - The loader that encountered the error
+     * @param error - The AWS error
+     * @returns Whether to continue processing
+     */
+    handleAwsSpecificError(loader, error) {
+        const serviceName = this.getServiceName(loader);
+        switch (error.name) {
+            case 'AccessDeniedException':
+                return this.errorHandler.handlePermissionError(serviceName, this.getResourceName(loader), error);
+            case 'ResourceNotFoundException':
+                return this.errorHandler.handleResourceNotFound(serviceName, this.getResourceName(loader), error);
+            case 'NetworkingError':
+            case 'TimeoutError':
+                const networkResult = this.errorHandler.handleNetworkError(serviceName, error);
+                return networkResult.shouldContinue;
+            case 'ThrottlingException':
+            case 'TooManyRequestsException':
+                this.logger.warn(`Rate limiting encountered for ${serviceName}, continuing with other sources`);
+                return true;
+            case 'ServiceUnavailableException':
+                return this.errorHandler.handleAwsUnavailable(serviceName, error);
+            case 'CredentialsError':
+                this.logger.error(`AWS credentials error for ${serviceName}: ${error.message}`);
+                this.logger.error('Please check AWS credentials configuration');
+                return this.errorHandler.handleAwsUnavailable(serviceName, error);
+            default:
+                // Handle as general configuration error
+                return this.errorHandler.handleConfigurationError(serviceName, error);
+        }
+    }
+    /**
+     * Get the service name for a loader.
+     * @param loader - The configuration loader
+     * @returns The service name
+     */
+    getServiceName(loader) {
+        if (loader instanceof SecretsManagerLoader) {
+            return 'AWS Secrets Manager';
+        }
+        else if (loader instanceof SSMParameterStoreLoader) {
+            return 'AWS Systems Manager Parameter Store';
+        }
+        else if (loader instanceof EnvironmentLoader) {
+            return 'Environment Variables';
+        }
+        else {
+            return 'Unknown Service';
+        }
+    }
+    /**
+     * Get the resource name for a loader.
+     * @param loader - The configuration loader
+     * @returns The resource name
+     */
+    getResourceName(loader) {
+        if (loader instanceof SecretsManagerLoader) {
+            return this.getSecretsManagerPath();
+        }
+        else if (loader instanceof SSMParameterStoreLoader) {
+            return this.getSSMParameterPath();
+        }
+        else {
+            return 'configuration';
+        }
+    }
+    /**
+     * Load configuration with retry logic for retryable errors.
+     * @param loader - The configuration loader
+     * @param maxRetries - Maximum number of retries
+     * @returns Promise resolving to configuration data
+     */
+    async loadWithRetry(loader, maxRetries = 3) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                return await loader.load();
+            }
+            catch (error) {
+                const loaderError = error instanceof Error ? error : new Error(String(error));
+                lastError = loaderError;
+                // Check if error is retryable
+                if (!this.errorHandler.isRetryableError(loaderError) || attempt === maxRetries) {
+                    throw loaderError;
+                }
+                // Wait before retrying
+                const delay = this.errorHandler.getRetryDelay(attempt);
+                this.logger.warn(`Retrying ${loader.getName()} in ${delay}ms (attempt ${attempt}/${maxRetries})`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        // This should never be reached, but just in case
+        throw lastError || new Error('Unknown error during retry');
+    }
+    /**
+     * Check availability with timeout and error handling.
+     * @param loader - The configuration loader
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Promise resolving to availability status
+     */
+    async checkAvailabilityWithTimeout(loader, timeoutMs = 5000) {
+        try {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Availability check timeout')), timeoutMs);
+            });
+            const availabilityPromise = loader.isAvailable();
+            return await Promise.race([availabilityPromise, timeoutPromise]);
+        }
+        catch (error) {
+            const loaderError = error instanceof Error ? error : new Error(String(error));
+            if (this.options.enableLogging) {
+                this.logger.debug(`Availability check failed for ${loader.getName()}: ${loaderError.message}`);
+            }
+            return false;
+        }
+    }
+};
+AwsConfigurationLoaderService = AwsConfigurationLoaderService_1 = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject('INTEGRATION_OPTIONS')),
+    __metadata("design:paramtypes", [Object])
+], AwsConfigurationLoaderService);
+export { AwsConfigurationLoaderService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-configuration-loader.service.js","sourceRoot":"","sources":["../../../../../../src/integration/providers/aws-configuration-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger, Inject, Optional } from '@nestjs/common';\r\nimport {\r\n  ConfigLoader,\r\n  SecretsManagerLoader,\r\n  SSMParameterStoreLoader,\r\n  EnvironmentLoader,\r\n} from '@dyanet/config-aws';\r\nimport { IntegrationOptions } from '../interfaces/integration-options.interface';\r\nimport { ConfigurationSource, ConfigurationSourceType } from '../interfaces/configuration-source.interface';\r\n\r\nimport { ErrorHandlerService } from '../services/error-handler.service';\r\n\r\n/**\r\n * Service for loading configuration from AWS sources for integration with @nestjs/config.\r\n * Uses existing AWS loaders to fetch configuration and provides namespace-aware loading capabilities.\r\n */\r\n@Injectable()\r\nexport class AwsConfigurationLoaderService {\r\n  private readonly logger = new Logger(AwsConfigurationLoaderService.name);\r\n  private readonly loaders: ConfigLoader[];\r\n  private readonly options: IntegrationOptions;\r\n  private readonly errorHandler: ErrorHandlerService;\r\n\r\n  constructor(\r\n    @Optional() @Inject('INTEGRATION_OPTIONS') options?: IntegrationOptions\r\n  ) {\r\n    this.options = options || {};\r\n    this.errorHandler = new ErrorHandlerService(this.options);\r\n    this.loaders = this.createLoaders();\r\n  }\r\n\r\n  /**\r\n   * Load configuration from AWS sources.\r\n   * @returns Promise resolving to configuration data\r\n   */\r\n  async loadConfiguration(): Promise<Record<string, any>> {\r\n    const mergedConfig: Record<string, any> = {};\r\n    const sources: ConfigurationSource[] = [];\r\n\r\n    for (const loader of this.loaders) {\r\n      try {\r\n        // Check if loader is available in current environment with timeout\r\n        const isAvailable = await this.checkAvailabilityWithTimeout(loader);\r\n        \r\n        if (!isAvailable) {\r\n          if (this.options.enableLogging) {\r\n            this.logger.debug(`Skipping ${loader.getName()} - not available in current environment`);\r\n          }\r\n          continue;\r\n        }\r\n\r\n        if (this.options.enableLogging) {\r\n          this.logger.debug(`Loading configuration from ${loader.getName()}`);\r\n        }\r\n\r\n        // Load configuration from this source with retry logic for AWS services\r\n        const loaderConfig = loader instanceof EnvironmentLoader \r\n          ? await loader.load() \r\n          : await this.loadWithRetry(loader);\r\n        \r\n        // Create configuration source metadata\r\n        const source: ConfigurationSource = {\r\n          name: loader.getName(),\r\n          type: this.getSourceType(loader),\r\n          priority: this.getSourcePriority(loader),\r\n          data: loaderConfig,\r\n          loadedAt: new Date(),\r\n        };\r\n\r\n        sources.push(source);\r\n\r\n        // Merge with existing configuration based on precedence\r\n        Object.assign(mergedConfig, loaderConfig);\r\n        \r\n        if (this.options.enableLogging) {\r\n          const keyCount = Object.keys(loaderConfig).length;\r\n          this.logger.debug(`Loaded ${keyCount} configuration values from ${loader.getName()}`);\r\n        }\r\n      } catch (error) {\r\n        const loaderError = error instanceof Error ? error : new Error(String(error));\r\n        \r\n        // Log detailed error information for troubleshooting\r\n        this.errorHandler.logDetailedError(`loadConfiguration - ${loader.getName()}`, loaderError, {\r\n          loaderName: loader.getName(),\r\n          loaderType: this.getSourceType(loader),\r\n        });\r\n\r\n        // Handle specific error types\r\n        if (this.isAwsServiceError(loaderError)) {\r\n          const shouldContinue = this.handleAwsSpecificError(loader, loaderError);\r\n          if (!shouldContinue) {\r\n            throw loaderError;\r\n          }\r\n        } else {\r\n          // Handle general configuration errors\r\n          const shouldContinue = this.errorHandler.handleConfigurationError(loader.getName(), loaderError);\r\n          if (!shouldContinue) {\r\n            throw loaderError;\r\n          }\r\n        }\r\n\r\n        // Add error to source metadata\r\n        const errorSource: ConfigurationSource = {\r\n          name: loader.getName(),\r\n          type: this.getSourceType(loader),\r\n          priority: this.getSourcePriority(loader),\r\n          data: {},\r\n          loadedAt: new Date(),\r\n          errors: [loaderError.message],\r\n        };\r\n        sources.push(errorSource);\r\n      }\r\n    }\r\n\r\n    return mergedConfig;\r\n  }\r\n\r\n  /**\r\n   * Load configuration for specific namespaces from AWS sources.\r\n   * @param namespaces - Array of namespace names to load\r\n   * @returns Promise resolving to namespaced configuration data\r\n   */\r\n  async loadNamespacedConfiguration(namespaces: string[]): Promise<Record<string, Record<string, any>>> {\r\n    const result: Record<string, Record<string, any>> = {};\r\n    \r\n    // Initialize all namespaces\r\n    for (const namespace of namespaces) {\r\n      result[namespace] = {};\r\n    }\r\n\r\n    for (const loader of this.loaders) {\r\n      try {\r\n        // Check if loader is available in current environment with timeout\r\n        const isAvailable = await this.checkAvailabilityWithTimeout(loader);\r\n        \r\n        if (!isAvailable) {\r\n          if (this.options.enableLogging) {\r\n            this.logger.debug(`Skipping ${loader.getName()} for namespace loading - not available`);\r\n          }\r\n          continue;\r\n        }\r\n\r\n        if (this.options.enableLogging) {\r\n          this.logger.debug(`Loading namespaced configuration from ${loader.getName()}`);\r\n        }\r\n\r\n        // Load configuration from this source with retry logic for AWS services\r\n        const loaderConfig = loader instanceof EnvironmentLoader \r\n          ? await loader.load() \r\n          : await this.loadWithRetry(loader);\r\n        \r\n        // Distribute configuration to namespaces based on key prefixes or patterns\r\n        for (const namespace of namespaces) {\r\n          const namespacedConfig = this.extractNamespaceConfig(loaderConfig, namespace);\r\n          \r\n          if (Object.keys(namespacedConfig).length > 0) {\r\n            Object.assign(result[namespace]!, namespacedConfig);\r\n            \r\n            if (this.options.enableLogging) {\r\n              const keyCount = Object.keys(namespacedConfig).length;\r\n              this.logger.debug(`Loaded ${keyCount} values for namespace '${namespace}' from ${loader.getName()}`);\r\n            }\r\n          }\r\n        }\r\n      } catch (error) {\r\n        const loaderError = error instanceof Error ? error : new Error(String(error));\r\n        \r\n        // Log detailed error information for troubleshooting\r\n        this.errorHandler.logDetailedError(`loadNamespacedConfiguration - ${loader.getName()}`, loaderError, {\r\n          loaderName: loader.getName(),\r\n          loaderType: this.getSourceType(loader),\r\n          namespaces,\r\n        });\r\n\r\n        // Handle specific error types\r\n        if (this.isAwsServiceError(loaderError)) {\r\n          const shouldContinue = this.handleAwsSpecificError(loader, loaderError);\r\n          if (!shouldContinue) {\r\n            throw loaderError;\r\n          }\r\n        } else {\r\n          // Handle general configuration errors\r\n          const shouldContinue = this.errorHandler.handleConfigurationError(loader.getName(), loaderError);\r\n          if (!shouldContinue) {\r\n            throw loaderError;\r\n          }\r\n        }\r\n\r\n        // Create fallback configuration for each namespace\r\n        if (this.options.fallbackToLocal) {\r\n          for (const namespace of namespaces) {\r\n            const fallbackConfig = this.errorHandler.createFallbackConfiguration(namespace);\r\n            Object.assign(result[namespace]!, fallbackConfig);\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Check if AWS services are available.\r\n   * @returns Promise resolving to availability status\r\n   */\r\n  async isAvailable(): Promise<boolean> {\r\n    try {\r\n      // Check if at least one AWS loader is available\r\n      const availabilityChecks = this.loaders\r\n        .filter(loader => !(loader instanceof EnvironmentLoader)) // Skip environment loader\r\n        .map(loader => this.checkAvailabilityWithTimeout(loader));\r\n\r\n      if (availabilityChecks.length === 0) {\r\n        // No AWS loaders configured\r\n        return false;\r\n      }\r\n\r\n      // Wait for all availability checks to complete\r\n      const results = await Promise.allSettled(availabilityChecks);\r\n      \r\n      // Return true if at least one AWS service is available\r\n      return results.some(result => result.status === 'fulfilled' && result.value === true);\r\n    } catch (error) {\r\n      const availabilityError = error instanceof Error ? error : new Error(String(error));\r\n      \r\n      this.errorHandler.logDetailedError('isAvailable', availabilityError);\r\n      \r\n      // Handle as AWS unavailable\r\n      this.errorHandler.handleAwsUnavailable('AWS Services', availabilityError);\r\n      \r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get all available configuration sources with their metadata.\r\n   * @returns Promise resolving to array of configuration sources\r\n   */\r\n  async getAvailableSources(): Promise<ConfigurationSource[]> {\r\n    const sources: ConfigurationSource[] = [];\r\n\r\n    for (const loader of this.loaders) {\r\n      try {\r\n        const isAvailable = await loader.isAvailable();\r\n        \r\n        if (isAvailable) {\r\n          const loaderConfig = await loader.load();\r\n          \r\n          const source: ConfigurationSource = {\r\n            name: loader.getName(),\r\n            type: this.getSourceType(loader),\r\n            priority: this.getSourcePriority(loader),\r\n            data: loaderConfig,\r\n            loadedAt: new Date(),\r\n          };\r\n\r\n          sources.push(source);\r\n        }\r\n      } catch (error) {\r\n        // Add source with error information\r\n        const source: ConfigurationSource = {\r\n          name: loader.getName(),\r\n          type: this.getSourceType(loader),\r\n          priority: this.getSourcePriority(loader),\r\n          data: {},\r\n          loadedAt: new Date(),\r\n          errors: [error instanceof Error ? error.message : String(error)],\r\n        };\r\n\r\n        sources.push(source);\r\n      }\r\n    }\r\n\r\n    return sources;\r\n  }\r\n\r\n  /**\r\n   * Create configuration loaders based on integration options.\r\n   * @returns Array of configuration loaders\r\n   */\r\n  private createLoaders(): ConfigLoader[] {\r\n    const loaders: ConfigLoader[] = [];\r\n\r\n    // Always include environment loader\r\n    loaders.push(new EnvironmentLoader({ prefix: this.options.envPrefix }));\r\n\r\n    // Add AWS Secrets Manager loader if configured\r\n    if (this.options.secretsManagerConfig?.enabled !== false) {\r\n      const secretsConfig = {\r\n        region: this.options.secretsManagerConfig?.region,\r\n        // Convert paths to secretName format expected by SecretsManagerLoader\r\n        secretName: this.getSecretsManagerPath(),\r\n      };\r\n      loaders.push(new SecretsManagerLoader(secretsConfig));\r\n    }\r\n\r\n    // Add SSM Parameter Store loader if configured\r\n    if (this.options.ssmConfig?.enabled !== false) {\r\n      const ssmConfig = {\r\n        region: this.options.ssmConfig?.region,\r\n        // Convert paths to parameterPath format expected by SSMParameterStoreLoader\r\n        parameterPath: this.getSSMParameterPath(),\r\n        withDecryption: this.options.ssmConfig?.decrypt ?? true,\r\n      };\r\n      loaders.push(new SSMParameterStoreLoader(ssmConfig));\r\n    }\r\n\r\n    return loaders;\r\n  }\r\n\r\n  /**\r\n   * Get the source type for a given loader.\r\n   * @param loader - The configuration loader\r\n   * @returns The configuration source type\r\n   */\r\n  private getSourceType(loader: ConfigLoader): ConfigurationSourceType {\r\n    if (loader instanceof EnvironmentLoader) {\r\n      return 'environment';\r\n    } else if (loader instanceof SecretsManagerLoader) {\r\n      return 'secrets-manager';\r\n    } else if (loader instanceof SSMParameterStoreLoader) {\r\n      return 'ssm';\r\n    } else {\r\n      return 'local-file';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the priority for a given loader based on precedence rules.\r\n   * @param loader - The configuration loader\r\n   * @returns The priority number (higher = higher priority)\r\n   */\r\n  private getSourcePriority(loader: ConfigLoader): number {\r\n    const precedence = this.options.precedence || 'aws-first';\r\n    \r\n    if (precedence === 'local-first') {\r\n      // Environment variables have highest priority\r\n      if (loader instanceof EnvironmentLoader) return 100;\r\n      if (loader instanceof SecretsManagerLoader) return 50;\r\n      if (loader instanceof SSMParameterStoreLoader) return 40;\r\n    } else if (precedence === 'aws-first') {\r\n      // AWS sources have higher priority\r\n      if (loader instanceof SecretsManagerLoader) return 100;\r\n      if (loader instanceof SSMParameterStoreLoader) return 90;\r\n      if (loader instanceof EnvironmentLoader) return 50;\r\n    } else {\r\n      // merge - equal priority, order matters\r\n      return 50;\r\n    }\r\n    \r\n    return 50;\r\n  }\r\n\r\n  /**\r\n   * Extract configuration for a specific namespace from loaded configuration.\r\n   * @param config - The loaded configuration\r\n   * @param namespace - The namespace to extract\r\n   * @returns Configuration values for the namespace\r\n   */\r\n  private extractNamespaceConfig(config: Record<string, any>, namespace: string): Record<string, any> {\r\n    const namespaceConfig: Record<string, any> = {};\r\n    const namespacePrefix = namespace.toUpperCase();\r\n\r\n    // Strategy 1: Look for direct namespace key (e.g., config.database)\r\n    if (config[namespace]) {\r\n      Object.assign(namespaceConfig, config[namespace]);\r\n    }\r\n\r\n    // Strategy 2: Look for keys that start with the namespace prefix (e.g., DATABASE_HOST)\r\n    for (const [key, value] of Object.entries(config)) {\r\n      const upperKey = key.toUpperCase();\r\n      \r\n      // Check if key starts with namespace prefix followed by underscore\r\n      if (upperKey.startsWith(`${namespacePrefix}_`)) {\r\n        // Remove namespace prefix and underscore, convert to camelCase\r\n        const namespacedKey = key.substring(namespace.length + 1);\r\n        const camelCaseKey = this.toCamelCase(namespacedKey);\r\n        \r\n        if (camelCaseKey) {\r\n          namespaceConfig[camelCaseKey] = value;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Strategy 3: Look for nested namespace paths (e.g., /app/database/host)\r\n    const nestedConfig = this.extractNestedNamespaceConfig(config, namespace);\r\n    Object.assign(namespaceConfig, nestedConfig);\r\n\r\n    return namespaceConfig;\r\n  }\r\n\r\n  /**\r\n   * Extract nested namespace configuration from hierarchical keys.\r\n   * @param config - The loaded configuration\r\n   * @param namespace - The namespace to extract\r\n   * @returns Configuration values for the namespace\r\n   */\r\n  private extractNestedNamespaceConfig(config: Record<string, any>, namespace: string): Record<string, any> {\r\n    const namespaceConfig: Record<string, any> = {};\r\n    const namespacePath = `/${namespace}/`;\r\n\r\n    for (const [key, value] of Object.entries(config)) {\r\n      // Check if key contains namespace path\r\n      if (key.includes(namespacePath)) {\r\n        // Extract the part after the namespace path\r\n        const pathIndex = key.indexOf(namespacePath);\r\n        const afterNamespace = key.substring(pathIndex + namespacePath.length);\r\n        \r\n        if (afterNamespace) {\r\n          // Convert path segments to nested object structure\r\n          const nestedKey = this.pathToNestedKey(afterNamespace);\r\n          this.setNestedValue(namespaceConfig, nestedKey, value);\r\n        }\r\n      }\r\n    }\r\n\r\n    return namespaceConfig;\r\n  }\r\n\r\n  /**\r\n   * Convert snake_case or kebab-case to camelCase.\r\n   * @param str - String to convert\r\n   * @returns camelCase string\r\n   */\r\n  private toCamelCase(str: string): string {\r\n    return str\r\n      .toLowerCase()\r\n      .replace(/[_-](.)/g, (_, char) => char.toUpperCase());\r\n  }\r\n\r\n  /**\r\n   * Convert path segments to nested key structure.\r\n   * @param path - Path string (e.g., \"host/port\")\r\n   * @returns Nested key structure\r\n   */\r\n  private pathToNestedKey(path: string): string {\r\n    return path\r\n      .split('/')\r\n      .map(segment => this.toCamelCase(segment))\r\n      .join('.');\r\n  }\r\n\r\n  /**\r\n   * Set a nested value in an object using dot notation.\r\n   * @param obj - Target object\r\n   * @param path - Dot notation path\r\n   * @param value - Value to set\r\n   */\r\n  private setNestedValue(obj: Record<string, any>, path: string, value: any): void {\r\n    const keys = path.split('.');\r\n    let current = obj;\r\n\r\n    for (let i = 0; i < keys.length - 1; i++) {\r\n      const key = keys[i];\r\n      if (key && (!(key in current) || typeof current[key] !== 'object')) {\r\n        current[key] = {};\r\n      }\r\n      if (key) {\r\n        current = current[key];\r\n      }\r\n    }\r\n\r\n    const lastKey = keys[keys.length - 1];\r\n    if (lastKey) {\r\n      current[lastKey] = value;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the Secrets Manager path based on configuration.\r\n   * @returns The secrets manager path\r\n   */\r\n  private getSecretsManagerPath(): string {\r\n    const paths = this.options.secretsManagerConfig?.paths;\r\n    if (!paths) {\r\n      return '/nestjs-config-aws';\r\n    }\r\n\r\n    // Use the first available path or default\r\n    return paths.production || paths.development || paths.test || '/nestjs-config-aws';\r\n  }\r\n\r\n  /**\r\n   * Get the SSM Parameter Store path based on configuration.\r\n   * @returns The SSM parameter path\r\n   */\r\n  private getSSMParameterPath(): string {\r\n    const paths = this.options.ssmConfig?.paths;\r\n    if (!paths) {\r\n      return '/nestjs-config-aws';\r\n    }\r\n\r\n    // Use the first available path or default\r\n    return paths.production || paths.development || paths.test || '/nestjs-config-aws';\r\n  }\r\n\r\n  /**\r\n   * Check if an error is an AWS service error.\r\n   * @param error - The error to check\r\n   * @returns Whether the error is from an AWS service\r\n   */\r\n  private isAwsServiceError(error: Error): boolean {\r\n    // AWS SDK errors typically have specific names\r\n    const awsErrorNames = [\r\n      'AccessDeniedException',\r\n      'ResourceNotFoundException',\r\n      'InvalidRequestException',\r\n      'ThrottlingException',\r\n      'ServiceUnavailableException',\r\n      'NetworkingError',\r\n      'TimeoutError',\r\n      'CredentialsError',\r\n      'UnknownEndpoint',\r\n    ];\r\n\r\n    return awsErrorNames.includes(error.name) || error.message.includes('AWS');\r\n  }\r\n\r\n  /**\r\n   * Handle AWS-specific errors with appropriate strategies.\r\n   * @param loader - The loader that encountered the error\r\n   * @param error - The AWS error\r\n   * @returns Whether to continue processing\r\n   */\r\n  private handleAwsSpecificError(loader: ConfigLoader, error: Error): boolean {\r\n    const serviceName = this.getServiceName(loader);\r\n\r\n    switch (error.name) {\r\n      case 'AccessDeniedException':\r\n        return this.errorHandler.handlePermissionError(\r\n          serviceName,\r\n          this.getResourceName(loader),\r\n          error\r\n        );\r\n\r\n      case 'ResourceNotFoundException':\r\n        return this.errorHandler.handleResourceNotFound(\r\n          serviceName,\r\n          this.getResourceName(loader),\r\n          error\r\n        );\r\n\r\n      case 'NetworkingError':\r\n      case 'TimeoutError':\r\n        const networkResult = this.errorHandler.handleNetworkError(serviceName, error);\r\n        return networkResult.shouldContinue;\r\n\r\n      case 'ThrottlingException':\r\n      case 'TooManyRequestsException':\r\n        this.logger.warn(`Rate limiting encountered for ${serviceName}, continuing with other sources`);\r\n        return true;\r\n\r\n      case 'ServiceUnavailableException':\r\n        return this.errorHandler.handleAwsUnavailable(serviceName, error);\r\n\r\n      case 'CredentialsError':\r\n        this.logger.error(`AWS credentials error for ${serviceName}: ${error.message}`);\r\n        this.logger.error('Please check AWS credentials configuration');\r\n        return this.errorHandler.handleAwsUnavailable(serviceName, error);\r\n\r\n      default:\r\n        // Handle as general configuration error\r\n        return this.errorHandler.handleConfigurationError(serviceName, error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the service name for a loader.\r\n   * @param loader - The configuration loader\r\n   * @returns The service name\r\n   */\r\n  private getServiceName(loader: ConfigLoader): string {\r\n    if (loader instanceof SecretsManagerLoader) {\r\n      return 'AWS Secrets Manager';\r\n    } else if (loader instanceof SSMParameterStoreLoader) {\r\n      return 'AWS Systems Manager Parameter Store';\r\n    } else if (loader instanceof EnvironmentLoader) {\r\n      return 'Environment Variables';\r\n    } else {\r\n      return 'Unknown Service';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the resource name for a loader.\r\n   * @param loader - The configuration loader\r\n   * @returns The resource name\r\n   */\r\n  private getResourceName(loader: ConfigLoader): string {\r\n    if (loader instanceof SecretsManagerLoader) {\r\n      return this.getSecretsManagerPath();\r\n    } else if (loader instanceof SSMParameterStoreLoader) {\r\n      return this.getSSMParameterPath();\r\n    } else {\r\n      return 'configuration';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load configuration with retry logic for retryable errors.\r\n   * @param loader - The configuration loader\r\n   * @param maxRetries - Maximum number of retries\r\n   * @returns Promise resolving to configuration data\r\n   */\r\n  private async loadWithRetry(loader: ConfigLoader, maxRetries: number = 3): Promise<Record<string, any>> {\r\n    let lastError: Error | null = null;\r\n\r\n    for (let attempt = 1; attempt <= maxRetries; attempt++) {\r\n      try {\r\n        return await loader.load();\r\n      } catch (error) {\r\n        const loaderError = error instanceof Error ? error : new Error(String(error));\r\n        lastError = loaderError;\r\n\r\n        // Check if error is retryable\r\n        if (!this.errorHandler.isRetryableError(loaderError) || attempt === maxRetries) {\r\n          throw loaderError;\r\n        }\r\n\r\n        // Wait before retrying\r\n        const delay = this.errorHandler.getRetryDelay(attempt);\r\n        this.logger.warn(`Retrying ${loader.getName()} in ${delay}ms (attempt ${attempt}/${maxRetries})`);\r\n        \r\n        await new Promise(resolve => setTimeout(resolve, delay));\r\n      }\r\n    }\r\n\r\n    // This should never be reached, but just in case\r\n    throw lastError || new Error('Unknown error during retry');\r\n  }\r\n\r\n  /**\r\n   * Check availability with timeout and error handling.\r\n   * @param loader - The configuration loader\r\n   * @param timeoutMs - Timeout in milliseconds\r\n   * @returns Promise resolving to availability status\r\n   */\r\n  private async checkAvailabilityWithTimeout(loader: ConfigLoader, timeoutMs: number = 5000): Promise<boolean> {\r\n    try {\r\n      const timeoutPromise = new Promise<boolean>((_, reject) => {\r\n        setTimeout(() => reject(new Error('Availability check timeout')), timeoutMs);\r\n      });\r\n\r\n      const availabilityPromise = loader.isAvailable();\r\n\r\n      return await Promise.race([availabilityPromise, timeoutPromise]);\r\n    } catch (error) {\r\n      const loaderError = error instanceof Error ? error : new Error(String(error));\r\n      \r\n      if (this.options.enableLogging) {\r\n        this.logger.debug(`Availability check failed for ${loader.getName()}: ${loaderError.message}`);\r\n      }\r\n\r\n      return false;\r\n    }\r\n  }\r\n}"]}