@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/nestjs-config-aws/src/integration/providers/configuration-factory.provider.js

@@ -0,0 +1,382 @@
+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 ConfigurationFactoryProviderImpl_1;
+import { Injectable, Logger, Inject, Optional } from '@nestjs/common';
+import { registerAs } from '@nestjs/config';
+import { PrecedenceHandlerService } from '../services/precedence-handler.service';
+import { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';
+/**
+ * Implementation of ConfigurationFactoryProvider that creates configuration factories
+ * for @nestjs/config integration with AWS configuration sources.
+ */
+let ConfigurationFactoryProviderImpl = ConfigurationFactoryProviderImpl_1 = class ConfigurationFactoryProviderImpl {
+    precedenceHandler;
+    options;
+    logger = new Logger(ConfigurationFactoryProviderImpl_1.name);
+    constructor(precedenceHandler, options) {
+        this.precedenceHandler = precedenceHandler;
+        this.options = options;
+    }
+    /**
+     * Create a configuration factory for a specific namespace.
+     * @param namespace - The namespace for the configuration
+     * @param config - The configuration data
+     * @returns A configuration factory that can be used with @nestjs/config
+     */
+    createFactory(namespace, config) {
+        this.logger.debug(`Creating configuration factory for namespace: ${namespace}`);
+        // Create a factory function that returns the configuration
+        const factory = () => {
+            this.logger.debug(`Factory called for namespace: ${namespace}`);
+            const processedConfig = this.processConfigurationValues(config);
+            // Add metadata for debugging and introspection
+            if (this.options?.enableLogging) {
+                this.logger.debug(`Factory returning ${Object.keys(processedConfig).length} configuration keys for namespace: ${namespace}`);
+            }
+            return processedConfig;
+        };
+        // If namespace is provided, use registerAs to create a namespaced factory
+        if (namespace && namespace.trim() !== '') {
+            const namespacedFactory = registerAs(namespace, factory);
+            // Enhance the factory with additional metadata for better integration
+            namespacedFactory.__namespace = namespace;
+            namespacedFactory.__isAwsFactory = true;
+            namespacedFactory.__configKeys = Object.keys(config);
+            return namespacedFactory;
+        }
+        // For non-namespaced factories, add metadata as well
+        factory.__isAwsFactory = true;
+        factory.__configKeys = Object.keys(config);
+        return factory;
+    }
+    /**
+     * Create multiple namespaced configuration factories from a configuration object.
+     * @param config - The configuration data organized by namespace
+     * @returns Array of configuration factories
+     */
+    createNamespacedFactories(config) {
+        this.logger.debug(`Creating namespaced factories for ${Object.keys(config).length} namespaces`);
+        const factories = [];
+        for (const [namespace, namespaceConfig] of Object.entries(config)) {
+            if (this.isValidNamespaceConfig(namespace, namespaceConfig)) {
+                try {
+                    const factory = this.createFactory(namespace, namespaceConfig);
+                    factories.push(factory);
+                    this.logger.debug(`Created factory for namespace: ${namespace}`);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to create factory for namespace ${namespace}:`, error);
+                }
+            }
+            else {
+                this.logger.warn(`Skipping invalid namespace configuration: ${namespace}`);
+            }
+        }
+        return factories;
+    }
+    /**
+     * Merge AWS configuration with existing local configuration using precedence rules.
+     * @param awsConfig - Configuration loaded from AWS sources
+     * @param localConfig - Local configuration data
+     * @returns Merged configuration data
+     */
+    mergeWithExisting(awsConfig, localConfig) {
+        this.logger.debug('Merging AWS configuration with local configuration');
+        // Create configuration sources for precedence handling
+        const sources = [
+            {
+                name: 'local-config',
+                type: 'local-file',
+                priority: 1,
+                data: localConfig,
+                loadedAt: new Date()
+            },
+            {
+                name: 'aws-config',
+                type: 'secrets-manager', // Assume AWS config is from secrets manager for now
+                priority: 2,
+                data: awsConfig,
+                loadedAt: new Date()
+            }
+        ];
+        // Use AWS-first precedence by default
+        const merged = this.precedenceHandler.applyPrecedenceRules(sources, 'aws-first');
+        this.logger.debug(`Merged configuration with ${Object.keys(merged).length} top-level keys`);
+        return merged;
+    }
+    /**
+     * Create an enhanced AWS configuration factory with metadata.
+     * @param namespace - Optional namespace for the configuration
+     * @param config - The configuration data
+     * @param sources - Sources that contributed to this configuration
+     * @param precedenceRule - Precedence rule applied to this configuration
+     * @returns Enhanced AWS configuration factory
+     */
+    createAwsConfigurationFactory(namespace, config, sources, precedenceRule) {
+        const baseFactory = namespace
+            ? this.createFactory(namespace, config)
+            : this.createFactory('', config);
+        // Enhance the factory with AWS-specific metadata
+        const awsFactory = baseFactory;
+        awsFactory.namespace = namespace;
+        awsFactory.sources = sources;
+        awsFactory.precedenceRule = precedenceRule;
+        this.logger.debug(`Created AWS configuration factory with ${sources.length} sources and precedence: ${precedenceRule}`);
+        return awsFactory;
+    }
+    /**
+     * Create configuration factories from multiple sources with proper organization.
+     * @param sourceConfigs - Map of source name to configuration data
+     * @param namespaces - Optional list of namespaces to organize configuration
+     * @returns Array of configuration factories organized by namespace
+     */
+    createFactoriesFromSources(sourceConfigs, namespaces) {
+        this.logger.debug(`Creating factories from ${sourceConfigs.size} sources`);
+        const factories = [];
+        if (namespaces && namespaces.length > 0) {
+            // Create namespaced factories
+            for (const namespace of namespaces) {
+                const namespaceConfig = this.extractNamespaceConfig(sourceConfigs, namespace);
+                if (Object.keys(namespaceConfig).length > 0) {
+                    const factory = this.createFactory(namespace, namespaceConfig);
+                    factories.push(factory);
+                }
+            }
+        }
+        else {
+            // Create a single factory with all configuration
+            const mergedConfig = this.mergeSourceConfigs(sourceConfigs);
+            if (Object.keys(mergedConfig).length > 0) {
+                const factory = this.createFactory('', mergedConfig);
+                factories.push(factory);
+            }
+        }
+        this.logger.debug(`Created ${factories.length} factories from sources`);
+        return factories;
+    }
+    /**
+     * Create configuration factories from sources with precedence rules.
+     * @param sources - Array of configuration sources
+     * @param precedenceRule - Precedence rule to apply
+     * @param namespaces - Optional list of namespaces to organize configuration
+     * @returns Array of configuration factories
+     */
+    createFactoriesWithPrecedence(sources, precedenceRule, namespaces) {
+        this.logger.debug(`Creating factories with precedence rule: ${precedenceRule}`);
+        // Validate sources first
+        const validation = this.precedenceHandler.validateSources(sources);
+        if (!validation.valid) {
+            this.logger.error('Invalid sources provided:', validation.issues);
+            throw new Error(`Invalid configuration sources: ${validation.issues.join(', ')}`);
+        }
+        const factories = [];
+        if (namespaces && namespaces.length > 0) {
+            // Create namespaced factories with precedence
+            for (const namespace of namespaces) {
+                const namespaceSources = this.extractNamespaceSources(sources, namespace);
+                if (namespaceSources.length > 0) {
+                    const mergedConfig = this.precedenceHandler.applyPrecedenceRules(namespaceSources, precedenceRule);
+                    const factory = this.createAwsConfigurationFactory(namespace, mergedConfig, namespaceSources, precedenceRule);
+                    factories.push(factory);
+                }
+            }
+        }
+        else {
+            // Create a single factory with all configuration
+            const mergedConfig = this.precedenceHandler.applyPrecedenceRules(sources, precedenceRule);
+            const factory = this.createAwsConfigurationFactory(undefined, mergedConfig, sources, precedenceRule);
+            factories.push(factory);
+        }
+        this.logger.debug(`Created ${factories.length} factories with precedence`);
+        return factories;
+    }
+    /**
+     * Merge configuration with explicit precedence rule.
+     * @param sources - Configuration sources
+     * @param precedenceRule - Precedence rule to apply
+     * @returns Merged configuration data
+     */
+    mergeWithPrecedence(sources, precedenceRule) {
+        this.logger.debug(`Merging ${sources.length} sources with precedence: ${precedenceRule}`);
+        const validation = this.precedenceHandler.validateSources(sources);
+        if (!validation.valid) {
+            this.logger.error('Invalid sources provided:', validation.issues);
+            throw new Error(`Invalid configuration sources: ${validation.issues.join(', ')}`);
+        }
+        return this.precedenceHandler.applyPrecedenceRules(sources, precedenceRule);
+    }
+    /**
+     * Process configuration values to handle special cases and transformations.
+     * @param config - Raw configuration object
+     * @returns Processed configuration object
+     */
+    processConfigurationValues(config) {
+        const processed = {};
+        for (const [key, value] of Object.entries(config)) {
+            processed[key] = this.processValue(value);
+        }
+        return processed;
+    }
+    /**
+     * Process individual configuration values.
+     * @param value - The value to process
+     * @returns Processed value
+     */
+    processValue(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        // Handle string values that might need type conversion
+        if (typeof value === 'string') {
+            return this.convertStringValue(value);
+        }
+        // Handle nested objects
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            return this.processConfigurationValues(value);
+        }
+        // Handle arrays
+        if (Array.isArray(value)) {
+            return value.map(item => this.processValue(item));
+        }
+        return value;
+    }
+    /**
+     * Convert string values to appropriate types.
+     * @param value - String value to convert
+     * @returns Converted value
+     */
+    convertStringValue(value) {
+        // Handle boolean strings
+        if (value.toLowerCase() === 'true')
+            return true;
+        if (value.toLowerCase() === 'false')
+            return false;
+        // Handle numeric strings
+        if (/^\d+$/.test(value)) {
+            const num = parseInt(value, 10);
+            return isNaN(num) ? value : num;
+        }
+        if (/^\d*\.\d+$/.test(value)) {
+            const num = parseFloat(value);
+            return isNaN(num) ? value : num;
+        }
+        // Handle JSON strings
+        if ((value.startsWith('{') && value.endsWith('}')) ||
+            (value.startsWith('[') && value.endsWith(']'))) {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                // If parsing fails, return as string
+                return value;
+            }
+        }
+        return value;
+    }
+    /**
+     * Validate if a namespace configuration is valid.
+     * @param namespace - The namespace name
+     * @param config - The configuration data
+     * @returns True if valid, false otherwise
+     */
+    isValidNamespaceConfig(namespace, config) {
+        return typeof namespace === 'string' &&
+            namespace.trim() !== '' &&
+            config !== null &&
+            config !== undefined &&
+            typeof config === 'object' &&
+            !Array.isArray(config);
+    }
+    /**
+     * Deep merge two configuration objects.
+     * @param target - Target object
+     * @param source - Source object
+     * @returns Merged object
+     */
+    deepMerge(target, source) {
+        const result = { ...target };
+        for (const [key, value] of Object.entries(source)) {
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                if (result[key] && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+                    result[key] = this.deepMerge(result[key], value);
+                }
+                else {
+                    result[key] = { ...value };
+                }
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Extract configuration for a specific namespace from multiple sources.
+     * @param sourceConfigs - Map of source configurations
+     * @param namespace - Target namespace
+     * @returns Configuration for the namespace
+     */
+    extractNamespaceConfig(sourceConfigs, namespace) {
+        let namespaceConfig = {};
+        for (const [sourceName, config] of sourceConfigs) {
+            if (config[namespace]) {
+                namespaceConfig = this.deepMerge(namespaceConfig, config[namespace]);
+                this.logger.debug(`Extracted ${namespace} config from source: ${sourceName}`);
+            }
+        }
+        return namespaceConfig;
+    }
+    /**
+     * Merge configuration from multiple sources.
+     * @param sourceConfigs - Map of source configurations
+     * @returns Merged configuration
+     */
+    mergeSourceConfigs(sourceConfigs) {
+        let mergedConfig = {};
+        for (const [sourceName, config] of sourceConfigs) {
+            mergedConfig = this.deepMerge(mergedConfig, config);
+            this.logger.debug(`Merged config from source: ${sourceName}`);
+        }
+        return mergedConfig;
+    }
+    /**
+     * Extract sources for a specific namespace.
+     * @param sources - All configuration sources
+     * @param namespace - Target namespace
+     * @returns Sources filtered for the namespace
+     */
+    extractNamespaceSources(sources, namespace) {
+        const namespaceSources = [];
+        for (const source of sources) {
+            if (source.namespace === namespace || source.data[namespace]) {
+                const namespaceData = source.namespace === namespace ? source.data : source.data[namespace];
+                if (namespaceData && typeof namespaceData === 'object') {
+                    namespaceSources.push({
+                        ...source,
+                        data: namespaceData,
+                        namespace: namespace
+                    });
+                }
+            }
+        }
+        return namespaceSources;
+    }
+};
+ConfigurationFactoryProviderImpl = ConfigurationFactoryProviderImpl_1 = __decorate([
+    Injectable(),
+    __param(1, Optional()),
+    __param(1, Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS)),
+    __metadata("design:paramtypes", [PrecedenceHandlerService, Object])
+], ConfigurationFactoryProviderImpl);
+export { ConfigurationFactoryProviderImpl };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration-factory.provider.js","sourceRoot":"","sources":["../../../../../../src/integration/providers/configuration-factory.provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger, Inject, Optional } from '@nestjs/common';\r\nimport { ConfigFactory, registerAs } from '@nestjs/config';\r\nimport { ConfigurationFactoryProvider, AwsConfigurationFactory } from '../interfaces/configuration-factory.interface';\r\nimport { ConfigurationSource } from '../interfaces/configuration-source.interface';\r\nimport { PrecedenceRule, IntegrationOptions } from '../interfaces/integration-options.interface';\r\nimport { PrecedenceHandlerService } from '../services/precedence-handler.service';\r\nimport { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';\r\n\r\n/**\r\n * Implementation of ConfigurationFactoryProvider that creates configuration factories\r\n * for @nestjs/config integration with AWS configuration sources.\r\n */\r\n@Injectable()\r\nexport class ConfigurationFactoryProviderImpl implements ConfigurationFactoryProvider {\r\n  private readonly logger = new Logger(ConfigurationFactoryProviderImpl.name);\r\n\r\n  constructor(\r\n    private readonly precedenceHandler: PrecedenceHandlerService,\r\n    @Optional() @Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS) \r\n    private readonly options?: IntegrationOptions\r\n  ) {}\r\n\r\n  /**\r\n   * Create a configuration factory for a specific namespace.\r\n   * @param namespace - The namespace for the configuration\r\n   * @param config - The configuration data\r\n   * @returns A configuration factory that can be used with @nestjs/config\r\n   */\r\n  createFactory(namespace: string, config: Record<string, any>): ConfigFactory {\r\n    this.logger.debug(`Creating configuration factory for namespace: ${namespace}`);\r\n    \r\n    // Create a factory function that returns the configuration\r\n    const factory = () => {\r\n      this.logger.debug(`Factory called for namespace: ${namespace}`);\r\n      const processedConfig = this.processConfigurationValues(config);\r\n      \r\n      // Add metadata for debugging and introspection\r\n      if (this.options?.enableLogging) {\r\n        this.logger.debug(`Factory returning ${Object.keys(processedConfig).length} configuration keys for namespace: ${namespace}`);\r\n      }\r\n      \r\n      return processedConfig;\r\n    };\r\n\r\n    // If namespace is provided, use registerAs to create a namespaced factory\r\n    if (namespace && namespace.trim() !== '') {\r\n      const namespacedFactory = registerAs(namespace, factory);\r\n      \r\n      // Enhance the factory with additional metadata for better integration\r\n      (namespacedFactory as any).__namespace = namespace;\r\n      (namespacedFactory as any).__isAwsFactory = true;\r\n      (namespacedFactory as any).__configKeys = Object.keys(config);\r\n      \r\n      return namespacedFactory;\r\n    }\r\n\r\n    // For non-namespaced factories, add metadata as well\r\n    (factory as any).__isAwsFactory = true;\r\n    (factory as any).__configKeys = Object.keys(config);\r\n    \r\n    return factory;\r\n  }\r\n\r\n  /**\r\n   * Create multiple namespaced configuration factories from a configuration object.\r\n   * @param config - The configuration data organized by namespace\r\n   * @returns Array of configuration factories\r\n   */\r\n  createNamespacedFactories(config: Record<string, any>): ConfigFactory[] {\r\n    this.logger.debug(`Creating namespaced factories for ${Object.keys(config).length} namespaces`);\r\n    const factories: ConfigFactory[] = [];\r\n    \r\n    for (const [namespace, namespaceConfig] of Object.entries(config)) {\r\n      if (this.isValidNamespaceConfig(namespace, namespaceConfig)) {\r\n        try {\r\n          const factory = this.createFactory(namespace, namespaceConfig as Record<string, any>);\r\n          factories.push(factory);\r\n          this.logger.debug(`Created factory for namespace: ${namespace}`);\r\n        } catch (error) {\r\n          this.logger.error(`Failed to create factory for namespace ${namespace}:`, error);\r\n        }\r\n      } else {\r\n        this.logger.warn(`Skipping invalid namespace configuration: ${namespace}`);\r\n      }\r\n    }\r\n    \r\n    return factories;\r\n  }\r\n\r\n  /**\r\n   * Merge AWS configuration with existing local configuration using precedence rules.\r\n   * @param awsConfig - Configuration loaded from AWS sources\r\n   * @param localConfig - Local configuration data\r\n   * @returns Merged configuration data\r\n   */\r\n  mergeWithExisting(\r\n    awsConfig: Record<string, any>, \r\n    localConfig: Record<string, any>\r\n  ): Record<string, any> {\r\n    this.logger.debug('Merging AWS configuration with local configuration');\r\n    \r\n    // Create configuration sources for precedence handling\r\n    const sources: ConfigurationSource[] = [\r\n      {\r\n        name: 'local-config',\r\n        type: 'local-file',\r\n        priority: 1,\r\n        data: localConfig,\r\n        loadedAt: new Date()\r\n      },\r\n      {\r\n        name: 'aws-config',\r\n        type: 'secrets-manager', // Assume AWS config is from secrets manager for now\r\n        priority: 2,\r\n        data: awsConfig,\r\n        loadedAt: new Date()\r\n      }\r\n    ];\r\n\r\n    // Use AWS-first precedence by default\r\n    const merged = this.precedenceHandler.applyPrecedenceRules(sources, 'aws-first');\r\n    \r\n    this.logger.debug(`Merged configuration with ${Object.keys(merged).length} top-level keys`);\r\n    return merged;\r\n  }\r\n\r\n  /**\r\n   * Create an enhanced AWS configuration factory with metadata.\r\n   * @param namespace - Optional namespace for the configuration\r\n   * @param config - The configuration data\r\n   * @param sources - Sources that contributed to this configuration\r\n   * @param precedenceRule - Precedence rule applied to this configuration\r\n   * @returns Enhanced AWS configuration factory\r\n   */\r\n  createAwsConfigurationFactory(\r\n    namespace: string | undefined,\r\n    config: Record<string, any>,\r\n    sources: ConfigurationSource[],\r\n    precedenceRule: PrecedenceRule\r\n  ): AwsConfigurationFactory {\r\n    const baseFactory = namespace \r\n      ? this.createFactory(namespace, config)\r\n      : this.createFactory('', config);\r\n\r\n    // Enhance the factory with AWS-specific metadata\r\n    const awsFactory = baseFactory as AwsConfigurationFactory;\r\n    awsFactory.namespace = namespace;\r\n    awsFactory.sources = sources;\r\n    awsFactory.precedenceRule = precedenceRule;\r\n\r\n    this.logger.debug(`Created AWS configuration factory with ${sources.length} sources and precedence: ${precedenceRule}`);\r\n    \r\n    return awsFactory;\r\n  }\r\n\r\n  /**\r\n   * Create configuration factories from multiple sources with proper organization.\r\n   * @param sourceConfigs - Map of source name to configuration data\r\n   * @param namespaces - Optional list of namespaces to organize configuration\r\n   * @returns Array of configuration factories organized by namespace\r\n   */\r\n  createFactoriesFromSources(\r\n    sourceConfigs: Map<string, Record<string, any>>,\r\n    namespaces?: string[]\r\n  ): ConfigFactory[] {\r\n    this.logger.debug(`Creating factories from ${sourceConfigs.size} sources`);\r\n    const factories: ConfigFactory[] = [];\r\n\r\n    if (namespaces && namespaces.length > 0) {\r\n      // Create namespaced factories\r\n      for (const namespace of namespaces) {\r\n        const namespaceConfig = this.extractNamespaceConfig(sourceConfigs, namespace);\r\n        if (Object.keys(namespaceConfig).length > 0) {\r\n          const factory = this.createFactory(namespace, namespaceConfig);\r\n          factories.push(factory);\r\n        }\r\n      }\r\n    } else {\r\n      // Create a single factory with all configuration\r\n      const mergedConfig = this.mergeSourceConfigs(sourceConfigs);\r\n      if (Object.keys(mergedConfig).length > 0) {\r\n        const factory = this.createFactory('', mergedConfig);\r\n        factories.push(factory);\r\n      }\r\n    }\r\n\r\n    this.logger.debug(`Created ${factories.length} factories from sources`);\r\n    return factories;\r\n  }\r\n\r\n  /**\r\n   * Create configuration factories from sources with precedence rules.\r\n   * @param sources - Array of configuration sources\r\n   * @param precedenceRule - Precedence rule to apply\r\n   * @param namespaces - Optional list of namespaces to organize configuration\r\n   * @returns Array of configuration factories\r\n   */\r\n  createFactoriesWithPrecedence(\r\n    sources: ConfigurationSource[],\r\n    precedenceRule: PrecedenceRule,\r\n    namespaces?: string[]\r\n  ): ConfigFactory[] {\r\n    this.logger.debug(`Creating factories with precedence rule: ${precedenceRule}`);\r\n    \r\n    // Validate sources first\r\n    const validation = this.precedenceHandler.validateSources(sources);\r\n    if (!validation.valid) {\r\n      this.logger.error('Invalid sources provided:', validation.issues);\r\n      throw new Error(`Invalid configuration sources: ${validation.issues.join(', ')}`);\r\n    }\r\n\r\n    const factories: ConfigFactory[] = [];\r\n\r\n    if (namespaces && namespaces.length > 0) {\r\n      // Create namespaced factories with precedence\r\n      for (const namespace of namespaces) {\r\n        const namespaceSources = this.extractNamespaceSources(sources, namespace);\r\n        if (namespaceSources.length > 0) {\r\n          const mergedConfig = this.precedenceHandler.applyPrecedenceRules(namespaceSources, precedenceRule);\r\n          const factory = this.createAwsConfigurationFactory(namespace, mergedConfig, namespaceSources, precedenceRule);\r\n          factories.push(factory);\r\n        }\r\n      }\r\n    } else {\r\n      // Create a single factory with all configuration\r\n      const mergedConfig = this.precedenceHandler.applyPrecedenceRules(sources, precedenceRule);\r\n      const factory = this.createAwsConfigurationFactory(undefined, mergedConfig, sources, precedenceRule);\r\n      factories.push(factory);\r\n    }\r\n\r\n    this.logger.debug(`Created ${factories.length} factories with precedence`);\r\n    return factories;\r\n  }\r\n\r\n  /**\r\n   * Merge configuration with explicit precedence rule.\r\n   * @param sources - Configuration sources\r\n   * @param precedenceRule - Precedence rule to apply\r\n   * @returns Merged configuration data\r\n   */\r\n  mergeWithPrecedence(\r\n    sources: ConfigurationSource[],\r\n    precedenceRule: PrecedenceRule\r\n  ): Record<string, any> {\r\n    this.logger.debug(`Merging ${sources.length} sources with precedence: ${precedenceRule}`);\r\n    \r\n    const validation = this.precedenceHandler.validateSources(sources);\r\n    if (!validation.valid) {\r\n      this.logger.error('Invalid sources provided:', validation.issues);\r\n      throw new Error(`Invalid configuration sources: ${validation.issues.join(', ')}`);\r\n    }\r\n\r\n    return this.precedenceHandler.applyPrecedenceRules(sources, precedenceRule);\r\n  }\r\n\r\n  /**\r\n   * Process configuration values to handle special cases and transformations.\r\n   * @param config - Raw configuration object\r\n   * @returns Processed configuration object\r\n   */\r\n  private processConfigurationValues(config: Record<string, any>): Record<string, any> {\r\n    const processed: Record<string, any> = {};\r\n\r\n    for (const [key, value] of Object.entries(config)) {\r\n      processed[key] = this.processValue(value);\r\n    }\r\n\r\n    return processed;\r\n  }\r\n\r\n  /**\r\n   * Process individual configuration values.\r\n   * @param value - The value to process\r\n   * @returns Processed value\r\n   */\r\n  private processValue(value: any): any {\r\n    if (value === null || value === undefined) {\r\n      return value;\r\n    }\r\n\r\n    // Handle string values that might need type conversion\r\n    if (typeof value === 'string') {\r\n      return this.convertStringValue(value);\r\n    }\r\n\r\n    // Handle nested objects\r\n    if (typeof value === 'object' && !Array.isArray(value)) {\r\n      return this.processConfigurationValues(value);\r\n    }\r\n\r\n    // Handle arrays\r\n    if (Array.isArray(value)) {\r\n      return value.map(item => this.processValue(item));\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * Convert string values to appropriate types.\r\n   * @param value - String value to convert\r\n   * @returns Converted value\r\n   */\r\n  private convertStringValue(value: string): any {\r\n    // Handle boolean strings\r\n    if (value.toLowerCase() === 'true') return true;\r\n    if (value.toLowerCase() === 'false') return false;\r\n\r\n    // Handle numeric strings\r\n    if (/^\\d+$/.test(value)) {\r\n      const num = parseInt(value, 10);\r\n      return isNaN(num) ? value : num;\r\n    }\r\n\r\n    if (/^\\d*\\.\\d+$/.test(value)) {\r\n      const num = parseFloat(value);\r\n      return isNaN(num) ? value : num;\r\n    }\r\n\r\n    // Handle JSON strings\r\n    if ((value.startsWith('{') && value.endsWith('}')) || \r\n        (value.startsWith('[') && value.endsWith(']'))) {\r\n      try {\r\n        return JSON.parse(value);\r\n      } catch {\r\n        // If parsing fails, return as string\r\n        return value;\r\n      }\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * Validate if a namespace configuration is valid.\r\n   * @param namespace - The namespace name\r\n   * @param config - The configuration data\r\n   * @returns True if valid, false otherwise\r\n   */\r\n  private isValidNamespaceConfig(namespace: string, config: any): boolean {\r\n    return typeof namespace === 'string' && \r\n           namespace.trim() !== '' &&\r\n           config !== null &&\r\n           config !== undefined &&\r\n           typeof config === 'object' &&\r\n           !Array.isArray(config);\r\n  }\r\n\r\n  /**\r\n   * Deep merge two configuration objects.\r\n   * @param target - Target object\r\n   * @param source - Source object\r\n   * @returns Merged object\r\n   */\r\n  private deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any> {\r\n    const result = { ...target };\r\n\r\n    for (const [key, value] of Object.entries(source)) {\r\n      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {\r\n        if (result[key] && typeof result[key] === 'object' && !Array.isArray(result[key])) {\r\n          result[key] = this.deepMerge(result[key], value);\r\n        } else {\r\n          result[key] = { ...value };\r\n        }\r\n      } else {\r\n        result[key] = value;\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Extract configuration for a specific namespace from multiple sources.\r\n   * @param sourceConfigs - Map of source configurations\r\n   * @param namespace - Target namespace\r\n   * @returns Configuration for the namespace\r\n   */\r\n  private extractNamespaceConfig(\r\n    sourceConfigs: Map<string, Record<string, any>>,\r\n    namespace: string\r\n  ): Record<string, any> {\r\n    let namespaceConfig: Record<string, any> = {};\r\n\r\n    for (const [sourceName, config] of sourceConfigs) {\r\n      if (config[namespace]) {\r\n        namespaceConfig = this.deepMerge(namespaceConfig, config[namespace]);\r\n        this.logger.debug(`Extracted ${namespace} config from source: ${sourceName}`);\r\n      }\r\n    }\r\n\r\n    return namespaceConfig;\r\n  }\r\n\r\n  /**\r\n   * Merge configuration from multiple sources.\r\n   * @param sourceConfigs - Map of source configurations\r\n   * @returns Merged configuration\r\n   */\r\n  private mergeSourceConfigs(sourceConfigs: Map<string, Record<string, any>>): Record<string, any> {\r\n    let mergedConfig: Record<string, any> = {};\r\n\r\n    for (const [sourceName, config] of sourceConfigs) {\r\n      mergedConfig = this.deepMerge(mergedConfig, config);\r\n      this.logger.debug(`Merged config from source: ${sourceName}`);\r\n    }\r\n\r\n    return mergedConfig;\r\n  }\r\n\r\n  /**\r\n   * Extract sources for a specific namespace.\r\n   * @param sources - All configuration sources\r\n   * @param namespace - Target namespace\r\n   * @returns Sources filtered for the namespace\r\n   */\r\n  private extractNamespaceSources(sources: ConfigurationSource[], namespace: string): ConfigurationSource[] {\r\n    const namespaceSources: ConfigurationSource[] = [];\r\n\r\n    for (const source of sources) {\r\n      if (source.namespace === namespace || source.data[namespace]) {\r\n        const namespaceData = source.namespace === namespace ? source.data : source.data[namespace];\r\n        \r\n        if (namespaceData && typeof namespaceData === 'object') {\r\n          namespaceSources.push({\r\n            ...source,\r\n            data: namespaceData,\r\n            namespace: namespace\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    return namespaceSources;\r\n  }\r\n}"]}

package/dist/esm/nestjs-config-aws/src/integration/providers/index.js

@@ -0,0 +1,4 @@
+// Integration providers exports
+export * from './configuration-factory.provider';
+export * from './aws-configuration-loader.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvaW50ZWdyYXRpb24vcHJvdmlkZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdDQUFnQztBQUNoQyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsb0NBQW9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBJbnRlZ3JhdGlvbiBwcm92aWRlcnMgZXhwb3J0c1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZ3VyYXRpb24tZmFjdG9yeS5wcm92aWRlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vYXdzLWNvbmZpZ3VyYXRpb24tbG9hZGVyLnNlcnZpY2UnOyJdfQ==