@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/nestjs-config-aws/src/integration/services/factory-registration.service.js

@@ -0,0 +1,514 @@
+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 FactoryRegistrationService_1;
+import { Injectable, Logger, Inject, Optional } from '@nestjs/common';
+import { ConfigurationFactoryProviderImpl } from '../providers/configuration-factory.provider';
+import { AwsConfigurationLoaderService } from '../providers/aws-configuration-loader.service';
+import { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';
+import { NamespaceHandlerService } from './namespace-handler.service';
+import { ValidationIntegrationService } from './validation-integration.service';
+/**
+ * Service responsible for registering configuration factories with @nestjs/config.
+ * This service creates and manages the bridge between AWS-loaded configuration
+ * and the standard @nestjs/config module.
+ */
+let FactoryRegistrationService = FactoryRegistrationService_1 = class FactoryRegistrationService {
+    configurationFactoryProvider;
+    awsConfigurationLoader;
+    namespaceHandler;
+    validationService;
+    options;
+    logger = new Logger(FactoryRegistrationService_1.name);
+    registeredFactories = new Map();
+    isInitialized = false;
+    constructor(configurationFactoryProvider, awsConfigurationLoader, namespaceHandler, validationService, options = {}) {
+        this.configurationFactoryProvider = configurationFactoryProvider;
+        this.awsConfigurationLoader = awsConfigurationLoader;
+        this.namespaceHandler = namespaceHandler;
+        this.validationService = validationService;
+        this.options = options;
+    }
+    /**
+     * Register configuration factories with @nestjs/config based on AWS-loaded configuration.
+     * This method loads configuration from AWS sources and creates factories that can be
+     * consumed by @nestjs/config.
+     *
+     * @returns Promise resolving to array of registered configuration factories
+     */
+    async registerFactories() {
+        if (this.isInitialized) {
+            this.logger.debug('Factories already registered, returning cached factories');
+            return Array.from(this.registeredFactories.values());
+        }
+        try {
+            this.logger.debug('Starting factory registration process');
+            // Load configuration from AWS sources
+            const awsConfig = await this.loadAwsConfiguration();
+            // Create configuration factories based on options
+            const factories = await this.createConfigurationFactories(awsConfig);
+            // Register factories and track them
+            this.registerFactoriesInternal(factories);
+            this.isInitialized = true;
+            this.logger.log(`Successfully registered ${factories.length} configuration factories`);
+            return factories;
+        }
+        catch (error) {
+            const registrationError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to register configuration factories:', registrationError);
+            // Handle registration failure based on options
+            if (this.options.failOnAwsError) {
+                throw registrationError;
+            }
+            // Return empty factories array if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Falling back to empty configuration factories due to AWS error');
+                return [];
+            }
+            throw registrationError;
+        }
+    }
+    /**
+     * Register configuration factories asynchronously.
+     * This method is designed to work with @nestjs/config's forRootAsync pattern.
+     *
+     * @returns Promise resolving to array of configuration factories
+     */
+    async registerFactoriesAsync() {
+        this.logger.debug('Starting async factory registration');
+        try {
+            // Ensure AWS services are available before proceeding
+            const isAwsAvailable = await this.awsConfigurationLoader.isAvailable();
+            if (!isAwsAvailable && this.options.failOnAwsError) {
+                throw new Error('AWS services are not available and failOnAwsError is enabled');
+            }
+            if (!isAwsAvailable) {
+                this.logger.warn('AWS services not available, registering empty factories');
+                return [];
+            }
+            // Load configuration asynchronously
+            const factories = await this.registerFactories();
+            this.logger.debug(`Async factory registration completed with ${factories.length} factories`);
+            return factories;
+        }
+        catch (error) {
+            const asyncError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Async factory registration failed:', asyncError);
+            // Handle async registration failure
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Falling back to empty factories for async registration');
+                return [];
+            }
+            throw asyncError;
+        }
+    }
+    /**
+     * Create a single configuration factory for immediate use.
+     * This method can be used for synchronous factory creation.
+     *
+     * @param namespace - Optional namespace for the factory
+     * @param config - Configuration data to use for the factory
+     * @returns Configuration factory
+     */
+    createSyncFactory(namespace, config) {
+        this.logger.debug(`Creating synchronous factory for namespace: ${namespace || 'default'}`);
+        // Use provided config or create empty config
+        const factoryConfig = config || {};
+        // Create factory using the configuration factory provider
+        const factory = this.configurationFactoryProvider.createFactory(namespace || '', factoryConfig);
+        // Track the factory
+        const factoryKey = namespace || 'default';
+        this.registeredFactories.set(factoryKey, factory);
+        this.logger.debug(`Created synchronous factory: ${factoryKey}`);
+        return factory;
+    }
+    /**
+     * Register factories for specific namespaces.
+     * This method allows selective registration of configuration for specific namespaces.
+     *
+     * @param namespaces - Array of namespace names to register
+     * @returns Promise resolving to array of namespace-specific factories
+     */
+    async registerNamespacedFactories(namespaces) {
+        this.logger.debug(`Registering factories for namespaces: ${namespaces.join(', ')}`);
+        try {
+            // Load namespaced configuration from AWS
+            const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(namespaces);
+            // Create factories for each namespace
+            const factories = [];
+            for (const namespace of namespaces) {
+                const namespaceConfig = namespacedConfig[namespace];
+                if (namespaceConfig && Object.keys(namespaceConfig).length > 0) {
+                    const factory = this.configurationFactoryProvider.createFactory(namespace, namespaceConfig);
+                    factories.push(factory);
+                    // Track the factory
+                    this.registeredFactories.set(namespace, factory);
+                    this.logger.debug(`Created factory for namespace: ${namespace}`);
+                }
+                else {
+                    this.logger.warn(`No configuration found for namespace: ${namespace}`);
+                }
+            }
+            this.logger.log(`Successfully registered ${factories.length} namespaced factories`);
+            return factories;
+        }
+        catch (error) {
+            const namespacedError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to register namespaced factories:', namespacedError);
+            if (this.options.failOnAwsError) {
+                throw namespacedError;
+            }
+            // Return empty factories if fallback is enabled
+            return [];
+        }
+    }
+    /**
+     * Get all registered factories.
+     * @returns Map of factory names to configuration factories
+     */
+    getRegisteredFactories() {
+        return new Map(this.registeredFactories);
+    }
+    /**
+     * Get a specific registered factory by name.
+     * @param name - Name of the factory to retrieve
+     * @returns Configuration factory or undefined if not found
+     */
+    getFactory(name) {
+        return this.registeredFactories.get(name);
+    }
+    /**
+     * Check if factories have been initialized.
+     * @returns Whether factories have been registered
+     */
+    isFactoriesInitialized() {
+        return this.isInitialized;
+    }
+    /**
+     * Register validated namespace factories with schema validation.
+     * This method creates factories that validate configuration using Joi, class-validator, or custom functions.
+     *
+     * @param namespaces - Array of namespace names to register
+     * @param validationSchemas - Validation schemas for each namespace
+     * @param validationType - Type of validation to use
+     * @returns Promise resolving to array of validated namespace factories
+     */
+    async registerValidatedNamespaceFactories(namespaces, validationSchemas, validationType = 'custom') {
+        this.logger.debug(`Registering validated factories for namespaces: ${namespaces.join(', ')} with ${validationType} validation`);
+        try {
+            // Load namespaced configuration from AWS
+            const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(namespaces);
+            const sources = await this.awsConfigurationLoader.getAvailableSources();
+            // Create validated factories for each namespace
+            const factories = [];
+            for (const namespace of namespaces) {
+                const namespaceConfig = namespacedConfig[namespace];
+                const validationSchema = validationSchemas[namespace];
+                if (namespaceConfig && Object.keys(namespaceConfig).length > 0 && validationSchema) {
+                    try {
+                        // Create validated factory using the validation service
+                        const factory = this.validationService.createValidatedFactory(namespace, namespaceConfig, validationSchema, validationType, sources.filter(s => s.namespace === namespace || s.data[namespace]));
+                        factories.push(factory);
+                        // Track the factory
+                        this.registeredFactories.set(namespace, factory);
+                        this.logger.debug(`Created validated factory for namespace: ${namespace}`);
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to create validated factory for namespace ${namespace}:`, error);
+                        if (this.options.failOnAwsError) {
+                            throw error;
+                        }
+                    }
+                }
+                else {
+                    if (!namespaceConfig || Object.keys(namespaceConfig).length === 0) {
+                        this.logger.warn(`No configuration found for namespace: ${namespace}`);
+                    }
+                    if (!validationSchema) {
+                        this.logger.warn(`No validation schema provided for namespace: ${namespace}`);
+                    }
+                }
+            }
+            this.logger.log(`Successfully registered ${factories.length} validated namespace factories`);
+            return factories;
+        }
+        catch (error) {
+            const validatedError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to register validated namespace factories:', validatedError);
+            if (this.options.failOnAwsError) {
+                throw validatedError;
+            }
+            // Return empty factories if fallback is enabled
+            return [];
+        }
+    }
+    /**
+     * Create enhanced namespace factories using the namespace handler service.
+     * This method provides improved namespace support with better configuration extraction.
+     *
+     * @param namespaces - Array of namespace names to create factories for
+     * @returns Promise resolving to array of enhanced namespace factories
+     */
+    async createEnhancedNamespaceFactories(namespaces) {
+        this.logger.debug(`Creating enhanced namespace factories for: ${namespaces.join(', ')}`);
+        try {
+            // Load configuration from AWS sources
+            const awsConfig = await this.awsConfigurationLoader.loadConfiguration();
+            const sources = await this.awsConfigurationLoader.getAvailableSources();
+            // Organize configuration by namespaces using the namespace handler
+            const organizedConfig = this.namespaceHandler.organizeConfigByNamespaces(awsConfig, namespaces);
+            // Create namespace factories using the namespace handler
+            const factories = this.namespaceHandler.createMultipleNamespaceFactories(organizedConfig, sources);
+            // Track the factories
+            for (const factory of factories) {
+                const namespace = factory.__namespace;
+                if (namespace) {
+                    this.registeredFactories.set(namespace, factory);
+                }
+            }
+            this.logger.log(`Successfully created ${factories.length} enhanced namespace factories`);
+            return factories;
+        }
+        catch (error) {
+            const enhancedError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create enhanced namespace factories:', enhancedError);
+            if (this.options.failOnAwsError) {
+                throw enhancedError;
+            }
+            return [];
+        }
+    }
+    /**
+     * Get validation recommendations for current configuration.
+     * This method analyzes the loaded configuration and provides validation recommendations.
+     *
+     * @returns Promise resolving to validation recommendations
+     */
+    async getValidationRecommendations() {
+        try {
+            const awsConfig = await this.awsConfigurationLoader.loadConfiguration();
+            return this.validationService.getValidationRecommendations(awsConfig);
+        }
+        catch (error) {
+            this.logger.error('Failed to get validation recommendations:', error);
+            return {
+                recommendedProvider: 'custom',
+                reasons: ['Unable to analyze configuration'],
+                examples: {}
+            };
+        }
+    }
+    /**
+     * Validate namespace access patterns for current configuration.
+     * This method checks if namespace configurations are properly structured for @nestjs/config access.
+     *
+     * @param namespaces - Namespaces to validate
+     * @returns Promise resolving to validation results
+     */
+    async validateNamespaceAccess(namespaces) {
+        try {
+            const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(namespaces);
+            const results = {};
+            for (const [namespace, config] of Object.entries(namespacedConfig)) {
+                results[namespace] = this.namespaceHandler.validateNamespaceAccess(namespace, config);
+            }
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Failed to validate namespace access:', error);
+            return {};
+        }
+    }
+    /**
+     * Reset the factory registration state.
+     * This method clears all registered factories and resets the initialization state.
+     */
+    reset() {
+        this.logger.debug('Resetting factory registration state');
+        this.registeredFactories.clear();
+        this.isInitialized = false;
+    }
+    /**
+     * Load configuration from AWS sources with error handling.
+     * @returns Promise resolving to AWS configuration data
+     */
+    async loadAwsConfiguration() {
+        try {
+            // Check if namespaces are specified for targeted loading
+            if (this.options.namespaces && this.options.namespaces.length > 0) {
+                this.logger.debug(`Loading configuration for namespaces: ${this.options.namespaces.join(', ')}`);
+                const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(this.options.namespaces);
+                // Flatten namespaced configuration for factory creation
+                const flattenedConfig = {};
+                for (const [namespace, config] of Object.entries(namespacedConfig)) {
+                    flattenedConfig[namespace] = config;
+                }
+                return flattenedConfig;
+            }
+            else {
+                // Load all available configuration
+                this.logger.debug('Loading all available AWS configuration');
+                return await this.awsConfigurationLoader.loadConfiguration();
+            }
+        }
+        catch (error) {
+            const loadError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to load AWS configuration:', loadError);
+            // Handle AWS unavailability
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('AWS configuration loading failed, using empty configuration');
+                return {};
+            }
+            throw loadError;
+        }
+    }
+    /**
+     * Create configuration factories based on loaded AWS configuration.
+     * @param awsConfig - Configuration data loaded from AWS
+     * @returns Promise resolving to array of configuration factories
+     */
+    async createConfigurationFactories(awsConfig) {
+        const factories = [];
+        try {
+            // Get configuration sources for metadata
+            const sources = await this.awsConfigurationLoader.getAvailableSources();
+            if (this.options.namespaces && this.options.namespaces.length > 0) {
+                // Create namespaced factories
+                factories.push(...this.createNamespacedFactoriesFromConfig(awsConfig, sources));
+            }
+            else {
+                // Create a single factory with all configuration
+                const factory = this.createSingleFactoryFromConfig(awsConfig, sources);
+                if (factory) {
+                    factories.push(factory);
+                }
+            }
+            this.logger.debug(`Created ${factories.length} configuration factories`);
+            return factories;
+        }
+        catch (error) {
+            const factoryError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create configuration factories:', factoryError);
+            throw factoryError;
+        }
+    }
+    /**
+     * Create namespaced factories from configuration data.
+     * @param config - Configuration data organized by namespace
+     * @param sources - Configuration sources metadata
+     * @returns Array of namespaced configuration factories
+     */
+    createNamespacedFactoriesFromConfig(config, sources) {
+        const factories = [];
+        for (const [namespace, namespaceConfig] of Object.entries(config)) {
+            if (this.isValidNamespaceConfig(namespace, namespaceConfig)) {
+                try {
+                    const factory = this.configurationFactoryProvider.createAwsConfigurationFactory(namespace, namespaceConfig, sources.filter(s => s.namespace === namespace || s.data[namespace]), this.options.precedence || 'aws-first');
+                    factories.push(factory);
+                    this.logger.debug(`Created namespaced factory: ${namespace}`);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to create factory for namespace ${namespace}:`, error);
+                }
+            }
+        }
+        return factories;
+    }
+    /**
+     * Create a single factory from all configuration data.
+     * @param config - All configuration data
+     * @param sources - Configuration sources metadata
+     * @returns Single configuration factory or null if no valid configuration
+     */
+    createSingleFactoryFromConfig(config, sources) {
+        if (!config || Object.keys(config).length === 0) {
+            this.logger.warn('No configuration data available for factory creation');
+            return null;
+        }
+        try {
+            const factory = this.configurationFactoryProvider.createAwsConfigurationFactory(undefined, config, sources, this.options.precedence || 'aws-first');
+            this.logger.debug('Created single configuration factory');
+            return factory;
+        }
+        catch (error) {
+            this.logger.error('Failed to create single configuration factory:', error);
+            return null;
+        }
+    }
+    /**
+     * Register factories internally and track them.
+     * @param factories - Array of factories to register
+     */
+    registerFactoriesInternal(factories) {
+        for (const factory of factories) {
+            // Determine factory name/key
+            const factoryKey = this.getFactoryKey(factory);
+            // Track the factory
+            this.registeredFactories.set(factoryKey, factory);
+            this.logger.debug(`Registered factory: ${factoryKey}`);
+        }
+    }
+    /**
+     * Get a unique key for a factory for tracking purposes.
+     * @param factory - Configuration factory
+     * @returns Unique key for the factory
+     */
+    getFactoryKey(factory) {
+        // Check if it's an AWS configuration factory with namespace
+        if ('namespace' in factory && factory.namespace) {
+            return factory.namespace;
+        }
+        // Generate a unique key based on factory properties
+        const factoryString = factory.toString();
+        const hash = this.simpleHash(factoryString);
+        return `factory_${hash}`;
+    }
+    /**
+     * Generate a simple hash for factory identification.
+     * @param str - String to hash
+     * @returns Simple hash value
+     */
+    simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * 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);
+    }
+};
+FactoryRegistrationService = FactoryRegistrationService_1 = __decorate([
+    Injectable(),
+    __param(4, Optional()),
+    __param(4, Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS)),
+    __metadata("design:paramtypes", [ConfigurationFactoryProviderImpl,
+        AwsConfigurationLoaderService,
+        NamespaceHandlerService,
+        ValidationIntegrationService, Object])
+], FactoryRegistrationService);
+export { FactoryRegistrationService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory-registration.service.js","sourceRoot":"","sources":["../../../../../../src/integration/services/factory-registration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger, Inject, Optional } from '@nestjs/common';\r\nimport { ConfigFactory } from '@nestjs/config';\r\nimport { ConfigurationFactoryProviderImpl } from '../providers/configuration-factory.provider';\r\nimport { AwsConfigurationLoaderService } from '../providers/aws-configuration-loader.service';\r\nimport { IntegrationOptions } from '../interfaces/integration-options.interface';\r\nimport { ConfigurationSource } from '../interfaces/configuration-source.interface';\r\nimport { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';\r\nimport { NamespaceHandlerService } from './namespace-handler.service';\r\nimport { ValidationIntegrationService } from './validation-integration.service';\r\n\r\n/**\r\n * Service responsible for registering configuration factories with @nestjs/config.\r\n * This service creates and manages the bridge between AWS-loaded configuration\r\n * and the standard @nestjs/config module.\r\n */\r\n@Injectable()\r\nexport class FactoryRegistrationService {\r\n  private readonly logger = new Logger(FactoryRegistrationService.name);\r\n  private readonly registeredFactories: Map<string, ConfigFactory> = new Map();\r\n  private isInitialized = false;\r\n\r\n  constructor(\r\n    private readonly configurationFactoryProvider: ConfigurationFactoryProviderImpl,\r\n    private readonly awsConfigurationLoader: AwsConfigurationLoaderService,\r\n    private readonly namespaceHandler: NamespaceHandlerService,\r\n    private readonly validationService: ValidationIntegrationService,\r\n    @Optional() @Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS) \r\n    private readonly options: IntegrationOptions = {}\r\n  ) {}\r\n\r\n  /**\r\n   * Register configuration factories with @nestjs/config based on AWS-loaded configuration.\r\n   * This method loads configuration from AWS sources and creates factories that can be\r\n   * consumed by @nestjs/config.\r\n   * \r\n   * @returns Promise resolving to array of registered configuration factories\r\n   */\r\n  async registerFactories(): Promise<ConfigFactory[]> {\r\n    if (this.isInitialized) {\r\n      this.logger.debug('Factories already registered, returning cached factories');\r\n      return Array.from(this.registeredFactories.values());\r\n    }\r\n\r\n    try {\r\n      this.logger.debug('Starting factory registration process');\r\n      \r\n      // Load configuration from AWS sources\r\n      const awsConfig = await this.loadAwsConfiguration();\r\n      \r\n      // Create configuration factories based on options\r\n      const factories = await this.createConfigurationFactories(awsConfig);\r\n      \r\n      // Register factories and track them\r\n      this.registerFactoriesInternal(factories);\r\n      \r\n      this.isInitialized = true;\r\n      this.logger.log(`Successfully registered ${factories.length} configuration factories`);\r\n      \r\n      return factories;\r\n    } catch (error) {\r\n      const registrationError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to register configuration factories:', registrationError);\r\n      \r\n      // Handle registration failure based on options\r\n      if (this.options.failOnAwsError) {\r\n        throw registrationError;\r\n      }\r\n      \r\n      // Return empty factories array if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Falling back to empty configuration factories due to AWS error');\r\n        return [];\r\n      }\r\n      \r\n      throw registrationError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Register configuration factories asynchronously.\r\n   * This method is designed to work with @nestjs/config's forRootAsync pattern.\r\n   * \r\n   * @returns Promise resolving to array of configuration factories\r\n   */\r\n  async registerFactoriesAsync(): Promise<ConfigFactory[]> {\r\n    this.logger.debug('Starting async factory registration');\r\n    \r\n    try {\r\n      // Ensure AWS services are available before proceeding\r\n      const isAwsAvailable = await this.awsConfigurationLoader.isAvailable();\r\n      \r\n      if (!isAwsAvailable && this.options.failOnAwsError) {\r\n        throw new Error('AWS services are not available and failOnAwsError is enabled');\r\n      }\r\n      \r\n      if (!isAwsAvailable) {\r\n        this.logger.warn('AWS services not available, registering empty factories');\r\n        return [];\r\n      }\r\n      \r\n      // Load configuration asynchronously\r\n      const factories = await this.registerFactories();\r\n      \r\n      this.logger.debug(`Async factory registration completed with ${factories.length} factories`);\r\n      return factories;\r\n    } catch (error) {\r\n      const asyncError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Async factory registration failed:', asyncError);\r\n      \r\n      // Handle async registration failure\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Falling back to empty factories for async registration');\r\n        return [];\r\n      }\r\n      \r\n      throw asyncError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a single configuration factory for immediate use.\r\n   * This method can be used for synchronous factory creation.\r\n   * \r\n   * @param namespace - Optional namespace for the factory\r\n   * @param config - Configuration data to use for the factory\r\n   * @returns Configuration factory\r\n   */\r\n  createSyncFactory(namespace?: string, config?: Record<string, any>): ConfigFactory {\r\n    this.logger.debug(`Creating synchronous factory for namespace: ${namespace || 'default'}`);\r\n    \r\n    // Use provided config or create empty config\r\n    const factoryConfig = config || {};\r\n    \r\n    // Create factory using the configuration factory provider\r\n    const factory = this.configurationFactoryProvider.createFactory(\r\n      namespace || '',\r\n      factoryConfig\r\n    );\r\n    \r\n    // Track the factory\r\n    const factoryKey = namespace || 'default';\r\n    this.registeredFactories.set(factoryKey, factory);\r\n    \r\n    this.logger.debug(`Created synchronous factory: ${factoryKey}`);\r\n    return factory;\r\n  }\r\n\r\n  /**\r\n   * Register factories for specific namespaces.\r\n   * This method allows selective registration of configuration for specific namespaces.\r\n   * \r\n   * @param namespaces - Array of namespace names to register\r\n   * @returns Promise resolving to array of namespace-specific factories\r\n   */\r\n  async registerNamespacedFactories(namespaces: string[]): Promise<ConfigFactory[]> {\r\n    this.logger.debug(`Registering factories for namespaces: ${namespaces.join(', ')}`);\r\n    \r\n    try {\r\n      // Load namespaced configuration from AWS\r\n      const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(namespaces);\r\n      \r\n      // Create factories for each namespace\r\n      const factories: ConfigFactory[] = [];\r\n      \r\n      for (const namespace of namespaces) {\r\n        const namespaceConfig = namespacedConfig[namespace];\r\n        \r\n        if (namespaceConfig && Object.keys(namespaceConfig).length > 0) {\r\n          const factory = this.configurationFactoryProvider.createFactory(namespace, namespaceConfig);\r\n          factories.push(factory);\r\n          \r\n          // Track the factory\r\n          this.registeredFactories.set(namespace, factory);\r\n          \r\n          this.logger.debug(`Created factory for namespace: ${namespace}`);\r\n        } else {\r\n          this.logger.warn(`No configuration found for namespace: ${namespace}`);\r\n        }\r\n      }\r\n      \r\n      this.logger.log(`Successfully registered ${factories.length} namespaced factories`);\r\n      return factories;\r\n    } catch (error) {\r\n      const namespacedError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to register namespaced factories:', namespacedError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw namespacedError;\r\n      }\r\n      \r\n      // Return empty factories if fallback is enabled\r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get all registered factories.\r\n   * @returns Map of factory names to configuration factories\r\n   */\r\n  getRegisteredFactories(): Map<string, ConfigFactory> {\r\n    return new Map(this.registeredFactories);\r\n  }\r\n\r\n  /**\r\n   * Get a specific registered factory by name.\r\n   * @param name - Name of the factory to retrieve\r\n   * @returns Configuration factory or undefined if not found\r\n   */\r\n  getFactory(name: string): ConfigFactory | undefined {\r\n    return this.registeredFactories.get(name);\r\n  }\r\n\r\n  /**\r\n   * Check if factories have been initialized.\r\n   * @returns Whether factories have been registered\r\n   */\r\n  isFactoriesInitialized(): boolean {\r\n    return this.isInitialized;\r\n  }\r\n\r\n  /**\r\n   * Register validated namespace factories with schema validation.\r\n   * This method creates factories that validate configuration using Joi, class-validator, or custom functions.\r\n   * \r\n   * @param namespaces - Array of namespace names to register\r\n   * @param validationSchemas - Validation schemas for each namespace\r\n   * @param validationType - Type of validation to use\r\n   * @returns Promise resolving to array of validated namespace factories\r\n   */\r\n  async registerValidatedNamespaceFactories(\r\n    namespaces: string[],\r\n    validationSchemas: Record<string, any>,\r\n    validationType: 'joi' | 'class-validator' | 'custom' = 'custom'\r\n  ): Promise<ConfigFactory[]> {\r\n    this.logger.debug(`Registering validated factories for namespaces: ${namespaces.join(', ')} with ${validationType} validation`);\r\n    \r\n    try {\r\n      // Load namespaced configuration from AWS\r\n      const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(namespaces);\r\n      const sources = await this.awsConfigurationLoader.getAvailableSources();\r\n      \r\n      // Create validated factories for each namespace\r\n      const factories: ConfigFactory[] = [];\r\n      \r\n      for (const namespace of namespaces) {\r\n        const namespaceConfig = namespacedConfig[namespace];\r\n        const validationSchema = validationSchemas[namespace];\r\n        \r\n        if (namespaceConfig && Object.keys(namespaceConfig).length > 0 && validationSchema) {\r\n          try {\r\n            // Create validated factory using the validation service\r\n            const factory = this.validationService.createValidatedFactory(\r\n              namespace,\r\n              namespaceConfig,\r\n              validationSchema,\r\n              validationType,\r\n              sources.filter(s => s.namespace === namespace || s.data[namespace])\r\n            );\r\n            \r\n            factories.push(factory);\r\n            \r\n            // Track the factory\r\n            this.registeredFactories.set(namespace, factory);\r\n            \r\n            this.logger.debug(`Created validated factory for namespace: ${namespace}`);\r\n          } catch (error) {\r\n            this.logger.error(`Failed to create validated factory for namespace ${namespace}:`, error);\r\n            \r\n            if (this.options.failOnAwsError) {\r\n              throw error;\r\n            }\r\n          }\r\n        } else {\r\n          if (!namespaceConfig || Object.keys(namespaceConfig).length === 0) {\r\n            this.logger.warn(`No configuration found for namespace: ${namespace}`);\r\n          }\r\n          if (!validationSchema) {\r\n            this.logger.warn(`No validation schema provided for namespace: ${namespace}`);\r\n          }\r\n        }\r\n      }\r\n      \r\n      this.logger.log(`Successfully registered ${factories.length} validated namespace factories`);\r\n      return factories;\r\n    } catch (error) {\r\n      const validatedError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to register validated namespace factories:', validatedError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw validatedError;\r\n      }\r\n      \r\n      // Return empty factories if fallback is enabled\r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create enhanced namespace factories using the namespace handler service.\r\n   * This method provides improved namespace support with better configuration extraction.\r\n   * \r\n   * @param namespaces - Array of namespace names to create factories for\r\n   * @returns Promise resolving to array of enhanced namespace factories\r\n   */\r\n  async createEnhancedNamespaceFactories(namespaces: string[]): Promise<ConfigFactory[]> {\r\n    this.logger.debug(`Creating enhanced namespace factories for: ${namespaces.join(', ')}`);\r\n    \r\n    try {\r\n      // Load configuration from AWS sources\r\n      const awsConfig = await this.awsConfigurationLoader.loadConfiguration();\r\n      const sources = await this.awsConfigurationLoader.getAvailableSources();\r\n      \r\n      // Organize configuration by namespaces using the namespace handler\r\n      const organizedConfig = this.namespaceHandler.organizeConfigByNamespaces(awsConfig, namespaces);\r\n      \r\n      // Create namespace factories using the namespace handler\r\n      const factories = this.namespaceHandler.createMultipleNamespaceFactories(organizedConfig, sources);\r\n      \r\n      // Track the factories\r\n      for (const factory of factories) {\r\n        const namespace = (factory as any).__namespace;\r\n        if (namespace) {\r\n          this.registeredFactories.set(namespace, factory);\r\n        }\r\n      }\r\n      \r\n      this.logger.log(`Successfully created ${factories.length} enhanced namespace factories`);\r\n      return factories;\r\n    } catch (error) {\r\n      const enhancedError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create enhanced namespace factories:', enhancedError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw enhancedError;\r\n      }\r\n      \r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get validation recommendations for current configuration.\r\n   * This method analyzes the loaded configuration and provides validation recommendations.\r\n   * \r\n   * @returns Promise resolving to validation recommendations\r\n   */\r\n  async getValidationRecommendations(): Promise<Record<string, any>> {\r\n    try {\r\n      const awsConfig = await this.awsConfigurationLoader.loadConfiguration();\r\n      return this.validationService.getValidationRecommendations(awsConfig);\r\n    } catch (error) {\r\n      this.logger.error('Failed to get validation recommendations:', error);\r\n      return {\r\n        recommendedProvider: 'custom',\r\n        reasons: ['Unable to analyze configuration'],\r\n        examples: {}\r\n      };\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate namespace access patterns for current configuration.\r\n   * This method checks if namespace configurations are properly structured for @nestjs/config access.\r\n   * \r\n   * @param namespaces - Namespaces to validate\r\n   * @returns Promise resolving to validation results\r\n   */\r\n  async validateNamespaceAccess(namespaces: string[]): Promise<Record<string, any>> {\r\n    try {\r\n      const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(namespaces);\r\n      const results: Record<string, any> = {};\r\n      \r\n      for (const [namespace, config] of Object.entries(namespacedConfig)) {\r\n        results[namespace] = this.namespaceHandler.validateNamespaceAccess(namespace, config);\r\n      }\r\n      \r\n      return results;\r\n    } catch (error) {\r\n      this.logger.error('Failed to validate namespace access:', error);\r\n      return {};\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reset the factory registration state.\r\n   * This method clears all registered factories and resets the initialization state.\r\n   */\r\n  reset(): void {\r\n    this.logger.debug('Resetting factory registration state');\r\n    this.registeredFactories.clear();\r\n    this.isInitialized = false;\r\n  }\r\n\r\n  /**\r\n   * Load configuration from AWS sources with error handling.\r\n   * @returns Promise resolving to AWS configuration data\r\n   */\r\n  private async loadAwsConfiguration(): Promise<Record<string, any>> {\r\n    try {\r\n      // Check if namespaces are specified for targeted loading\r\n      if (this.options.namespaces && this.options.namespaces.length > 0) {\r\n        this.logger.debug(`Loading configuration for namespaces: ${this.options.namespaces.join(', ')}`);\r\n        const namespacedConfig = await this.awsConfigurationLoader.loadNamespacedConfiguration(this.options.namespaces);\r\n        \r\n        // Flatten namespaced configuration for factory creation\r\n        const flattenedConfig: Record<string, any> = {};\r\n        for (const [namespace, config] of Object.entries(namespacedConfig)) {\r\n          flattenedConfig[namespace] = config;\r\n        }\r\n        \r\n        return flattenedConfig;\r\n      } else {\r\n        // Load all available configuration\r\n        this.logger.debug('Loading all available AWS configuration');\r\n        return await this.awsConfigurationLoader.loadConfiguration();\r\n      }\r\n    } catch (error) {\r\n      const loadError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to load AWS configuration:', loadError);\r\n      \r\n      // Handle AWS unavailability\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('AWS configuration loading failed, using empty configuration');\r\n        return {};\r\n      }\r\n      \r\n      throw loadError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create configuration factories based on loaded AWS configuration.\r\n   * @param awsConfig - Configuration data loaded from AWS\r\n   * @returns Promise resolving to array of configuration factories\r\n   */\r\n  private async createConfigurationFactories(awsConfig: Record<string, any>): Promise<ConfigFactory[]> {\r\n    const factories: ConfigFactory[] = [];\r\n    \r\n    try {\r\n      // Get configuration sources for metadata\r\n      const sources = await this.awsConfigurationLoader.getAvailableSources();\r\n      \r\n      if (this.options.namespaces && this.options.namespaces.length > 0) {\r\n        // Create namespaced factories\r\n        factories.push(...this.createNamespacedFactoriesFromConfig(awsConfig, sources));\r\n      } else {\r\n        // Create a single factory with all configuration\r\n        const factory = this.createSingleFactoryFromConfig(awsConfig, sources);\r\n        if (factory) {\r\n          factories.push(factory);\r\n        }\r\n      }\r\n      \r\n      this.logger.debug(`Created ${factories.length} configuration factories`);\r\n      return factories;\r\n    } catch (error) {\r\n      const factoryError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create configuration factories:', factoryError);\r\n      throw factoryError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create namespaced factories from configuration data.\r\n   * @param config - Configuration data organized by namespace\r\n   * @param sources - Configuration sources metadata\r\n   * @returns Array of namespaced configuration factories\r\n   */\r\n  private createNamespacedFactoriesFromConfig(\r\n    config: Record<string, any>,\r\n    sources: ConfigurationSource[]\r\n  ): ConfigFactory[] {\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.configurationFactoryProvider.createAwsConfigurationFactory(\r\n            namespace,\r\n            namespaceConfig as Record<string, any>,\r\n            sources.filter(s => s.namespace === namespace || s.data[namespace]),\r\n            this.options.precedence || 'aws-first'\r\n          );\r\n          \r\n          factories.push(factory);\r\n          this.logger.debug(`Created namespaced factory: ${namespace}`);\r\n        } catch (error) {\r\n          this.logger.error(`Failed to create factory for namespace ${namespace}:`, error);\r\n        }\r\n      }\r\n    }\r\n    \r\n    return factories;\r\n  }\r\n\r\n  /**\r\n   * Create a single factory from all configuration data.\r\n   * @param config - All configuration data\r\n   * @param sources - Configuration sources metadata\r\n   * @returns Single configuration factory or null if no valid configuration\r\n   */\r\n  private createSingleFactoryFromConfig(\r\n    config: Record<string, any>,\r\n    sources: ConfigurationSource[]\r\n  ): ConfigFactory | null {\r\n    if (!config || Object.keys(config).length === 0) {\r\n      this.logger.warn('No configuration data available for factory creation');\r\n      return null;\r\n    }\r\n    \r\n    try {\r\n      const factory = this.configurationFactoryProvider.createAwsConfigurationFactory(\r\n        undefined,\r\n        config,\r\n        sources,\r\n        this.options.precedence || 'aws-first'\r\n      );\r\n      \r\n      this.logger.debug('Created single configuration factory');\r\n      return factory;\r\n    } catch (error) {\r\n      this.logger.error('Failed to create single configuration factory:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Register factories internally and track them.\r\n   * @param factories - Array of factories to register\r\n   */\r\n  private registerFactoriesInternal(factories: ConfigFactory[]): void {\r\n    for (const factory of factories) {\r\n      // Determine factory name/key\r\n      const factoryKey = this.getFactoryKey(factory);\r\n      \r\n      // Track the factory\r\n      this.registeredFactories.set(factoryKey, factory);\r\n      \r\n      this.logger.debug(`Registered factory: ${factoryKey}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get a unique key for a factory for tracking purposes.\r\n   * @param factory - Configuration factory\r\n   * @returns Unique key for the factory\r\n   */\r\n  private getFactoryKey(factory: ConfigFactory): string {\r\n    // Check if it's an AWS configuration factory with namespace\r\n    if ('namespace' in factory && factory.namespace) {\r\n      return factory.namespace as string;\r\n    }\r\n    \r\n    // Generate a unique key based on factory properties\r\n    const factoryString = factory.toString();\r\n    const hash = this.simpleHash(factoryString);\r\n    \r\n    return `factory_${hash}`;\r\n  }\r\n\r\n  /**\r\n   * Generate a simple hash for factory identification.\r\n   * @param str - String to hash\r\n   * @returns Simple hash value\r\n   */\r\n  private simpleHash(str: string): string {\r\n    let hash = 0;\r\n    for (let i = 0; i < str.length; i++) {\r\n      const char = str.charCodeAt(i);\r\n      hash = ((hash << 5) - hash) + char;\r\n      hash = hash & hash; // Convert to 32-bit integer\r\n    }\r\n    return Math.abs(hash).toString(36);\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}"]}

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

@@ -0,0 +1,10 @@
+// Integration services exports
+export * from './integration-state.service';
+export * from './error-handler.service';
+export * from './precedence-handler.service';
+export * from './factory-registration.service';
+export * from './nestjs-config-integration.service';
+export * from './async-config-helper.service';
+export * from './namespace-handler.service';
+export * from './validation-integration.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvaW50ZWdyYXRpb24vc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQStCO0FBQy9CLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxrQ0FBa0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEludGVncmF0aW9uIHNlcnZpY2VzIGV4cG9ydHNcclxuZXhwb3J0ICogZnJvbSAnLi9pbnRlZ3JhdGlvbi1zdGF0ZS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9lcnJvci1oYW5kbGVyLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3ByZWNlZGVuY2UtaGFuZGxlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9mYWN0b3J5LXJlZ2lzdHJhdGlvbi5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9uZXN0anMtY29uZmlnLWludGVncmF0aW9uLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2FzeW5jLWNvbmZpZy1oZWxwZXIuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbmFtZXNwYWNlLWhhbmRsZXIuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdmFsaWRhdGlvbi1pbnRlZ3JhdGlvbi5zZXJ2aWNlJzsiXX0=