@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/nestjs-config-aws/src/integration/services/async-config-helper.service.js

@@ -0,0 +1,363 @@
+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 AsyncConfigHelperService_1;
+import { Injectable, Logger, Inject, Optional } from '@nestjs/common';
+import { FactoryRegistrationService } from './factory-registration.service';
+import { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';
+/**
+ * Helper service for async configuration support with @nestjs/config.
+ * This service provides utilities for creating async configuration factories
+ * and managing dependency injection in async scenarios.
+ */
+let AsyncConfigHelperService = AsyncConfigHelperService_1 = class AsyncConfigHelperService {
+    factoryRegistrationService;
+    options;
+    logger = new Logger(AsyncConfigHelperService_1.name);
+    constructor(factoryRegistrationService, options = {}) {
+        this.factoryRegistrationService = factoryRegistrationService;
+        this.options = options;
+    }
+    /**
+     * Create an async configuration factory that loads AWS configuration.
+     * This factory can be used with @nestjs/config's load array.
+     *
+     * @returns Promise resolving to configuration factory
+     */
+    async createAsyncConfigFactory() {
+        this.logger.debug('Creating async configuration factory');
+        try {
+            // Register AWS factories and get the first one
+            const awsFactories = await this.factoryRegistrationService.registerFactories();
+            if (awsFactories.length === 0) {
+                this.logger.warn('No AWS factories available, creating empty factory');
+                return () => ({});
+            }
+            // Create a combined factory that merges all AWS factories
+            const combinedFactory = () => {
+                const combinedConfig = {};
+                for (const factory of awsFactories) {
+                    try {
+                        const factoryConfig = factory();
+                        Object.assign(combinedConfig, factoryConfig);
+                    }
+                    catch (error) {
+                        this.logger.error(`Error executing AWS factory:`, error);
+                    }
+                }
+                return combinedConfig;
+            };
+            this.logger.debug(`Created async configuration factory with ${awsFactories.length} AWS factories`);
+            return combinedFactory;
+        }
+        catch (error) {
+            const factoryError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create async configuration factory:', factoryError);
+            // Handle error based on options
+            if (this.options.failOnAwsError) {
+                throw factoryError;
+            }
+            // Return empty factory as fallback
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Returning empty factory due to AWS error');
+                return () => ({});
+            }
+            throw factoryError;
+        }
+    }
+    /**
+     * Create multiple async configuration factories for namespaces.
+     * This method creates separate factories for each namespace.
+     *
+     * @param namespaces - Array of namespace names
+     * @returns Promise resolving to array of namespaced configuration factories
+     */
+    async createAsyncNamespacedFactories(namespaces) {
+        this.logger.debug(`Creating async namespaced factories for: ${namespaces.join(', ')}`);
+        try {
+            const namespacedFactories = await this.factoryRegistrationService.registerNamespacedFactories(namespaces);
+            if (namespacedFactories.length === 0) {
+                this.logger.warn('No namespaced factories available, creating empty factories');
+                return namespaces.map(() => () => ({}));
+            }
+            this.logger.debug(`Created ${namespacedFactories.length} async namespaced factories`);
+            return namespacedFactories;
+        }
+        catch (error) {
+            const namespacedError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create async namespaced factories:', namespacedError);
+            // Handle error based on options
+            if (this.options.failOnAwsError) {
+                throw namespacedError;
+            }
+            // Return empty factories as fallback
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Returning empty namespaced factories due to AWS error');
+                return namespaces.map(() => () => ({}));
+            }
+            throw namespacedError;
+        }
+    }
+    /**
+     * Create an async factory function that can be used with dependency injection.
+     * This method creates a factory that can receive injected dependencies.
+     *
+     * @param dependencies - Array of dependency tokens to inject
+     * @returns Async factory function
+     */
+    createAsyncFactoryWithDependencies(dependencies = []) {
+        this.logger.debug(`Creating async factory with ${dependencies.length} dependencies`);
+        return async (..._injectedDependencies) => {
+            try {
+                this.logger.debug('Executing async factory with dependencies');
+                // Create AWS configuration factory
+                const awsFactory = await this.createAsyncConfigFactory();
+                // Create enhanced configuration options
+                const configOptions = {
+                    load: [awsFactory],
+                    isGlobal: this.options.registerGlobally ?? true,
+                    cache: this.options.factoryOptions?.cache ?? true,
+                    expandVariables: this.options.factoryOptions?.expandVariables ?? true,
+                };
+                this.logger.debug('Async factory with dependencies executed successfully');
+                return configOptions;
+            }
+            catch (error) {
+                const dependencyError = error instanceof Error ? error : new Error(String(error));
+                this.logger.error('Failed to execute async factory with dependencies:', dependencyError);
+                // Handle error based on options
+                if (this.options.failOnAwsError) {
+                    throw dependencyError;
+                }
+                // Return basic configuration as fallback
+                if (this.options.fallbackToLocal) {
+                    this.logger.warn('Returning basic configuration due to dependency error');
+                    return {
+                        load: [],
+                        isGlobal: this.options.registerGlobally ?? true,
+                        cache: this.options.factoryOptions?.cache ?? true,
+                        expandVariables: this.options.factoryOptions?.expandVariables ?? true,
+                    };
+                }
+                throw dependencyError;
+            }
+        };
+    }
+    /**
+     * Create an async factory that merges with existing configuration.
+     * This method creates a factory that can be combined with other configuration sources.
+     *
+     * @param existingFactory - Existing configuration factory to merge with
+     * @returns Promise resolving to merged configuration factory
+     */
+    async createMergedAsyncFactory(existingFactory) {
+        this.logger.debug('Creating merged async configuration factory');
+        try {
+            // Create AWS configuration factory
+            const awsFactory = await this.createAsyncConfigFactory();
+            // If no existing factory, return AWS factory
+            if (!existingFactory) {
+                return awsFactory;
+            }
+            // Create merged factory
+            const mergedFactory = () => {
+                const awsConfig = awsFactory();
+                const existingConfig = existingFactory();
+                // Merge configurations based on precedence
+                const precedence = this.options.precedence || 'aws-first';
+                if (precedence === 'aws-first') {
+                    return { ...existingConfig, ...awsConfig };
+                }
+                else if (precedence === 'local-first') {
+                    return { ...awsConfig, ...existingConfig };
+                }
+                else {
+                    // merge - deep merge both configurations
+                    return this.deepMerge(existingConfig, awsConfig);
+                }
+            };
+            this.logger.debug('Created merged async configuration factory');
+            return mergedFactory;
+        }
+        catch (error) {
+            const mergeError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create merged async factory:', mergeError);
+            // Handle error based on options
+            if (this.options.failOnAwsError) {
+                throw mergeError;
+            }
+            // Return existing factory or empty factory as fallback
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Returning existing factory due to merge error');
+                return existingFactory || (() => ({}));
+            }
+            throw mergeError;
+        }
+    }
+    /**
+     * Create configuration options for async module setup.
+     * This method creates options that can be used with ConfigModule.forRoot().
+     *
+     * @param baseOptions - Base configuration options to enhance
+     * @returns Promise resolving to enhanced configuration options
+     */
+    async createAsyncConfigOptions(baseOptions = {}) {
+        this.logger.debug('Creating async configuration options');
+        try {
+            // Create AWS configuration factory
+            const awsFactory = await this.createAsyncConfigFactory();
+            // Merge with existing load array
+            const existingLoad = baseOptions.load || [];
+            const enhancedLoad = [...existingLoad, awsFactory];
+            // Create enhanced options
+            const enhancedOptions = {
+                ...baseOptions,
+                load: enhancedLoad,
+                isGlobal: baseOptions.isGlobal !== undefined ? baseOptions.isGlobal : (this.options.registerGlobally ?? true),
+                cache: baseOptions.cache !== undefined ? baseOptions.cache : (this.options.factoryOptions?.cache ?? true),
+                expandVariables: baseOptions.expandVariables !== undefined ? baseOptions.expandVariables : (this.options.factoryOptions?.expandVariables ?? true),
+            };
+            this.logger.debug('Created async configuration options');
+            return enhancedOptions;
+        }
+        catch (error) {
+            const optionsError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create async configuration options:', optionsError);
+            // Handle error based on options
+            if (this.options.failOnAwsError) {
+                throw optionsError;
+            }
+            // Return base options as fallback
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Returning base options due to async error');
+                return baseOptions;
+            }
+            throw optionsError;
+        }
+    }
+    /**
+     * Check if AWS configuration is available for async loading.
+     * This method can be used to determine if AWS integration should be enabled.
+     *
+     * @returns Promise resolving to availability status
+     */
+    async checkAsyncAvailability() {
+        this.logger.debug('Checking async configuration availability');
+        const status = {
+            isAvailable: false,
+            factoriesCount: 0,
+            errors: []
+        };
+        try {
+            // Try to register factories to check availability
+            const factories = await this.factoryRegistrationService.registerFactories();
+            status.isAvailable = factories.length > 0;
+            status.factoriesCount = factories.length;
+            this.logger.debug(`Async availability check: available=${status.isAvailable}, factories=${status.factoriesCount}`);
+        }
+        catch (error) {
+            const availabilityError = error instanceof Error ? error : new Error(String(error));
+            status.errors.push(availabilityError.message);
+            this.logger.error('Async availability check failed:', availabilityError);
+        }
+        return status;
+    }
+    /**
+     * Create a factory that loads configuration on-demand.
+     * This factory delays AWS configuration loading until it's actually needed.
+     *
+     * @returns Configuration factory with lazy loading
+     */
+    createLazyAsyncFactory() {
+        this.logger.debug('Creating lazy async configuration factory');
+        let cachedConfig = null;
+        let loadingPromise = null;
+        return () => {
+            // Return cached config if available
+            if (cachedConfig !== null) {
+                return cachedConfig;
+            }
+            // If already loading, wait for the promise
+            if (loadingPromise) {
+                // For synchronous factory, we can't wait for async operations
+                // Return empty config and let the promise resolve in background
+                this.logger.warn('Lazy factory called while loading, returning empty config');
+                return {};
+            }
+            // Start loading configuration and update cache when complete
+            loadingPromise = this.loadConfigurationLazily()
+                .then((config) => {
+                cachedConfig = config;
+                loadingPromise = null;
+                return config;
+            })
+                .catch((error) => {
+                loadingPromise = null;
+                this.logger.error('Lazy loading failed:', error);
+                return {};
+            });
+            // Return empty config for now (will be populated on next call)
+            this.logger.debug('Started lazy loading, returning empty config');
+            return {};
+        };
+    }
+    /**
+     * Load configuration lazily for the lazy factory.
+     * @returns Promise resolving to configuration data
+     */
+    async loadConfigurationLazily() {
+        try {
+            this.logger.debug('Loading configuration lazily');
+            const awsFactory = await this.createAsyncConfigFactory();
+            const config = awsFactory();
+            this.logger.debug('Lazy configuration loading completed');
+            return config;
+        }
+        catch (error) {
+            const lazyError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Lazy configuration loading failed:', lazyError);
+            // Return empty config on error
+            return {};
+        }
+    }
+    /**
+     * 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;
+    }
+};
+AsyncConfigHelperService = AsyncConfigHelperService_1 = __decorate([
+    Injectable(),
+    __param(1, Optional()),
+    __param(1, Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS)),
+    __metadata("design:paramtypes", [FactoryRegistrationService, Object])
+], AsyncConfigHelperService);
+export { AsyncConfigHelperService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-config-helper.service.js","sourceRoot":"","sources":["../../../../../../src/integration/services/async-config-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger, Inject, Optional } from '@nestjs/common';\r\nimport { ConfigFactory, ConfigModuleOptions } from '@nestjs/config';\r\nimport { FactoryRegistrationService } from './factory-registration.service';\r\nimport { IntegrationOptions } from '../interfaces/integration-options.interface';\r\nimport { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';\r\n\r\n/**\r\n * Helper service for async configuration support with @nestjs/config.\r\n * This service provides utilities for creating async configuration factories\r\n * and managing dependency injection in async scenarios.\r\n */\r\n@Injectable()\r\nexport class AsyncConfigHelperService {\r\n  private readonly logger = new Logger(AsyncConfigHelperService.name);\r\n\r\n  constructor(\r\n    private readonly factoryRegistrationService: FactoryRegistrationService,\r\n    @Optional() @Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS) \r\n    private readonly options: IntegrationOptions = {}\r\n  ) {}\r\n\r\n  /**\r\n   * Create an async configuration factory that loads AWS configuration.\r\n   * This factory can be used with @nestjs/config's load array.\r\n   * \r\n   * @returns Promise resolving to configuration factory\r\n   */\r\n  async createAsyncConfigFactory(): Promise<ConfigFactory> {\r\n    this.logger.debug('Creating async configuration factory');\r\n    \r\n    try {\r\n      // Register AWS factories and get the first one\r\n      const awsFactories = await this.factoryRegistrationService.registerFactories();\r\n      \r\n      if (awsFactories.length === 0) {\r\n        this.logger.warn('No AWS factories available, creating empty factory');\r\n        return () => ({});\r\n      }\r\n      \r\n      // Create a combined factory that merges all AWS factories\r\n      const combinedFactory: ConfigFactory = () => {\r\n        const combinedConfig: Record<string, any> = {};\r\n        \r\n        for (const factory of awsFactories) {\r\n          try {\r\n            const factoryConfig = factory();\r\n            Object.assign(combinedConfig, factoryConfig);\r\n          } catch (error) {\r\n            this.logger.error(`Error executing AWS factory:`, error);\r\n          }\r\n        }\r\n        \r\n        return combinedConfig;\r\n      };\r\n      \r\n      this.logger.debug(`Created async configuration factory with ${awsFactories.length} AWS factories`);\r\n      return combinedFactory;\r\n    } catch (error) {\r\n      const factoryError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create async configuration factory:', factoryError);\r\n      \r\n      // Handle error based on options\r\n      if (this.options.failOnAwsError) {\r\n        throw factoryError;\r\n      }\r\n      \r\n      // Return empty factory as fallback\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Returning empty factory due to AWS error');\r\n        return () => ({});\r\n      }\r\n      \r\n      throw factoryError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create multiple async configuration factories for namespaces.\r\n   * This method creates separate factories for each namespace.\r\n   * \r\n   * @param namespaces - Array of namespace names\r\n   * @returns Promise resolving to array of namespaced configuration factories\r\n   */\r\n  async createAsyncNamespacedFactories(namespaces: string[]): Promise<ConfigFactory[]> {\r\n    this.logger.debug(`Creating async namespaced factories for: ${namespaces.join(', ')}`);\r\n    \r\n    try {\r\n      const namespacedFactories = await this.factoryRegistrationService.registerNamespacedFactories(namespaces);\r\n      \r\n      if (namespacedFactories.length === 0) {\r\n        this.logger.warn('No namespaced factories available, creating empty factories');\r\n        return namespaces.map(() => () => ({}));\r\n      }\r\n      \r\n      this.logger.debug(`Created ${namespacedFactories.length} async namespaced factories`);\r\n      return namespacedFactories;\r\n    } catch (error) {\r\n      const namespacedError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create async namespaced factories:', namespacedError);\r\n      \r\n      // Handle error based on options\r\n      if (this.options.failOnAwsError) {\r\n        throw namespacedError;\r\n      }\r\n      \r\n      // Return empty factories as fallback\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Returning empty namespaced factories due to AWS error');\r\n        return namespaces.map(() => () => ({}));\r\n      }\r\n      \r\n      throw namespacedError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create an async factory function that can be used with dependency injection.\r\n   * This method creates a factory that can receive injected dependencies.\r\n   * \r\n   * @param dependencies - Array of dependency tokens to inject\r\n   * @returns Async factory function\r\n   */\r\n  createAsyncFactoryWithDependencies(dependencies: any[] = []): (...args: any[]) => Promise<ConfigModuleOptions> {\r\n    this.logger.debug(`Creating async factory with ${dependencies.length} dependencies`);\r\n    \r\n    return async (..._injectedDependencies: any[]): Promise<ConfigModuleOptions> => {\r\n      try {\r\n        this.logger.debug('Executing async factory with dependencies');\r\n        \r\n        // Create AWS configuration factory\r\n        const awsFactory = await this.createAsyncConfigFactory();\r\n        \r\n        // Create enhanced configuration options\r\n        const configOptions: ConfigModuleOptions = {\r\n          load: [awsFactory],\r\n          isGlobal: this.options.registerGlobally ?? true,\r\n          cache: this.options.factoryOptions?.cache ?? true,\r\n          expandVariables: this.options.factoryOptions?.expandVariables ?? true,\r\n        };\r\n        \r\n        this.logger.debug('Async factory with dependencies executed successfully');\r\n        return configOptions;\r\n      } catch (error) {\r\n        const dependencyError = error instanceof Error ? error : new Error(String(error));\r\n        this.logger.error('Failed to execute async factory with dependencies:', dependencyError);\r\n        \r\n        // Handle error based on options\r\n        if (this.options.failOnAwsError) {\r\n          throw dependencyError;\r\n        }\r\n        \r\n        // Return basic configuration as fallback\r\n        if (this.options.fallbackToLocal) {\r\n          this.logger.warn('Returning basic configuration due to dependency error');\r\n          return {\r\n            load: [],\r\n            isGlobal: this.options.registerGlobally ?? true,\r\n            cache: this.options.factoryOptions?.cache ?? true,\r\n            expandVariables: this.options.factoryOptions?.expandVariables ?? true,\r\n          };\r\n        }\r\n        \r\n        throw dependencyError;\r\n      }\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create an async factory that merges with existing configuration.\r\n   * This method creates a factory that can be combined with other configuration sources.\r\n   * \r\n   * @param existingFactory - Existing configuration factory to merge with\r\n   * @returns Promise resolving to merged configuration factory\r\n   */\r\n  async createMergedAsyncFactory(existingFactory?: ConfigFactory): Promise<ConfigFactory> {\r\n    this.logger.debug('Creating merged async configuration factory');\r\n    \r\n    try {\r\n      // Create AWS configuration factory\r\n      const awsFactory = await this.createAsyncConfigFactory();\r\n      \r\n      // If no existing factory, return AWS factory\r\n      if (!existingFactory) {\r\n        return awsFactory;\r\n      }\r\n      \r\n      // Create merged factory\r\n      const mergedFactory: ConfigFactory = () => {\r\n        const awsConfig = awsFactory();\r\n        const existingConfig = existingFactory();\r\n        \r\n        // Merge configurations based on precedence\r\n        const precedence = this.options.precedence || 'aws-first';\r\n        \r\n        if (precedence === 'aws-first') {\r\n          return { ...existingConfig, ...awsConfig };\r\n        } else if (precedence === 'local-first') {\r\n          return { ...awsConfig, ...existingConfig };\r\n        } else {\r\n          // merge - deep merge both configurations\r\n          return this.deepMerge(existingConfig, awsConfig);\r\n        }\r\n      };\r\n      \r\n      this.logger.debug('Created merged async configuration factory');\r\n      return mergedFactory;\r\n    } catch (error) {\r\n      const mergeError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create merged async factory:', mergeError);\r\n      \r\n      // Handle error based on options\r\n      if (this.options.failOnAwsError) {\r\n        throw mergeError;\r\n      }\r\n      \r\n      // Return existing factory or empty factory as fallback\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Returning existing factory due to merge error');\r\n        return existingFactory || (() => ({}));\r\n      }\r\n      \r\n      throw mergeError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create configuration options for async module setup.\r\n   * This method creates options that can be used with ConfigModule.forRoot().\r\n   * \r\n   * @param baseOptions - Base configuration options to enhance\r\n   * @returns Promise resolving to enhanced configuration options\r\n   */\r\n  async createAsyncConfigOptions(baseOptions: ConfigModuleOptions = {}): Promise<ConfigModuleOptions> {\r\n    this.logger.debug('Creating async configuration options');\r\n    \r\n    try {\r\n      // Create AWS configuration factory\r\n      const awsFactory = await this.createAsyncConfigFactory();\r\n      \r\n      // Merge with existing load array\r\n      const existingLoad = baseOptions.load || [];\r\n      const enhancedLoad = [...existingLoad, awsFactory];\r\n      \r\n      // Create enhanced options\r\n      const enhancedOptions: ConfigModuleOptions = {\r\n        ...baseOptions,\r\n        load: enhancedLoad,\r\n        isGlobal: baseOptions.isGlobal !== undefined ? baseOptions.isGlobal : (this.options.registerGlobally ?? true),\r\n        cache: baseOptions.cache !== undefined ? baseOptions.cache : (this.options.factoryOptions?.cache ?? true),\r\n        expandVariables: baseOptions.expandVariables !== undefined ? baseOptions.expandVariables : (this.options.factoryOptions?.expandVariables ?? true),\r\n      };\r\n      \r\n      this.logger.debug('Created async configuration options');\r\n      return enhancedOptions;\r\n    } catch (error) {\r\n      const optionsError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create async configuration options:', optionsError);\r\n      \r\n      // Handle error based on options\r\n      if (this.options.failOnAwsError) {\r\n        throw optionsError;\r\n      }\r\n      \r\n      // Return base options as fallback\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Returning base options due to async error');\r\n        return baseOptions;\r\n      }\r\n      \r\n      throw optionsError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if AWS configuration is available for async loading.\r\n   * This method can be used to determine if AWS integration should be enabled.\r\n   * \r\n   * @returns Promise resolving to availability status\r\n   */\r\n  async checkAsyncAvailability(): Promise<{\r\n    isAvailable: boolean;\r\n    factoriesCount: number;\r\n    errors: string[];\r\n  }> {\r\n    this.logger.debug('Checking async configuration availability');\r\n    \r\n    const status = {\r\n      isAvailable: false,\r\n      factoriesCount: 0,\r\n      errors: [] as string[]\r\n    };\r\n\r\n    try {\r\n      // Try to register factories to check availability\r\n      const factories = await this.factoryRegistrationService.registerFactories();\r\n      \r\n      status.isAvailable = factories.length > 0;\r\n      status.factoriesCount = factories.length;\r\n      \r\n      this.logger.debug(`Async availability check: available=${status.isAvailable}, factories=${status.factoriesCount}`);\r\n    } catch (error) {\r\n      const availabilityError = error instanceof Error ? error : new Error(String(error));\r\n      status.errors.push(availabilityError.message);\r\n      this.logger.error('Async availability check failed:', availabilityError);\r\n    }\r\n\r\n    return status;\r\n  }\r\n\r\n  /**\r\n   * Create a factory that loads configuration on-demand.\r\n   * This factory delays AWS configuration loading until it's actually needed.\r\n   * \r\n   * @returns Configuration factory with lazy loading\r\n   */\r\n  createLazyAsyncFactory(): ConfigFactory {\r\n    this.logger.debug('Creating lazy async configuration factory');\r\n    \r\n    let cachedConfig: Record<string, any> | null = null;\r\n    let loadingPromise: Promise<Record<string, any>> | null = null;\r\n    \r\n    return () => {\r\n      // Return cached config if available\r\n      if (cachedConfig !== null) {\r\n        return cachedConfig;\r\n      }\r\n      \r\n      // If already loading, wait for the promise\r\n      if (loadingPromise) {\r\n        // For synchronous factory, we can't wait for async operations\r\n        // Return empty config and let the promise resolve in background\r\n        this.logger.warn('Lazy factory called while loading, returning empty config');\r\n        return {};\r\n      }\r\n      \r\n      // Start loading configuration and update cache when complete\r\n      loadingPromise = this.loadConfigurationLazily()\r\n        .then((config) => {\r\n          cachedConfig = config;\r\n          loadingPromise = null;\r\n          return config;\r\n        })\r\n        .catch((error) => {\r\n          loadingPromise = null;\r\n          this.logger.error('Lazy loading failed:', error);\r\n          return {};\r\n        });\r\n      \r\n      // Return empty config for now (will be populated on next call)\r\n      this.logger.debug('Started lazy loading, returning empty config');\r\n      return {};\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Load configuration lazily for the lazy factory.\r\n   * @returns Promise resolving to configuration data\r\n   */\r\n  private async loadConfigurationLazily(): Promise<Record<string, any>> {\r\n    try {\r\n      this.logger.debug('Loading configuration lazily');\r\n      \r\n      const awsFactory = await this.createAsyncConfigFactory();\r\n      const config = awsFactory();\r\n      \r\n      this.logger.debug('Lazy configuration loading completed');\r\n      return config;\r\n    } catch (error) {\r\n      const lazyError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Lazy configuration loading failed:', lazyError);\r\n      \r\n      // Return empty config on error\r\n      return {};\r\n    }\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}"]}