@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

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

@@ -0,0 +1,315 @@
+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 NestjsConfigIntegrationService_1;
+import { Injectable, Logger, Inject, Optional } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { FactoryRegistrationService } from './factory-registration.service';
+import { NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS } from '../nestjs-config-integration.module';
+/**
+ * Service that provides integration utilities for working with @nestjs/config.
+ * This service creates ConfigModule configurations that include AWS-sourced factories.
+ */
+let NestjsConfigIntegrationService = NestjsConfigIntegrationService_1 = class NestjsConfigIntegrationService {
+    factoryRegistrationService;
+    options;
+    logger = new Logger(NestjsConfigIntegrationService_1.name);
+    constructor(factoryRegistrationService, options = {}) {
+        this.factoryRegistrationService = factoryRegistrationService;
+        this.options = options;
+    }
+    /**
+     * Create a ConfigModule configuration with AWS-sourced factories.
+     * This method can be used to enhance existing @nestjs/config setups.
+     *
+     * @param baseOptions - Base ConfigModule options to enhance
+     * @returns Promise resolving to enhanced ConfigModule options
+     */
+    async createConfigModuleOptions(baseOptions = {}) {
+        this.logger.debug('Creating ConfigModule options with AWS integration');
+        try {
+            // Register AWS configuration factories
+            const awsFactories = await this.factoryRegistrationService.registerFactories();
+            // Merge AWS factories with existing load array
+            const existingLoad = baseOptions.load || [];
+            const enhancedLoad = [...existingLoad, ...awsFactories];
+            // Create enhanced options
+            const enhancedOptions = {
+                ...baseOptions,
+                load: enhancedLoad,
+                // Apply integration-specific options with proper precedence
+                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.log(`Enhanced ConfigModule options with ${awsFactories.length} AWS factories`);
+            return enhancedOptions;
+        }
+        catch (error) {
+            const enhancementError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create enhanced ConfigModule options:', enhancementError);
+            // Handle enhancement failure based on options
+            if (this.options.failOnAwsError) {
+                throw enhancementError;
+            }
+            // Return base options if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Falling back to base ConfigModule options due to AWS error');
+                return baseOptions;
+            }
+            throw enhancementError;
+        }
+    }
+    /**
+     * Create a ConfigModule configuration for async setup.
+     * This method works with ConfigModule.forRootAsync() pattern.
+     *
+     * @param baseOptions - Base async ConfigModule options to enhance
+     * @returns Promise resolving to enhanced async ConfigModule options
+     */
+    async createAsyncConfigModuleOptions(baseOptions = {}) {
+        this.logger.debug('Creating async ConfigModule options with AWS integration');
+        try {
+            // Create a factory function that includes AWS configuration
+            const enhancedUseFactory = async (...args) => {
+                // Call original factory if it exists
+                let baseConfig = {};
+                if (baseOptions.useFactory) {
+                    baseConfig = await baseOptions.useFactory(...args);
+                }
+                // Enhance with AWS configuration
+                return await this.createConfigModuleOptions(baseConfig);
+            };
+            // Create enhanced async options
+            const enhancedAsyncOptions = {
+                ...baseOptions,
+                useFactory: enhancedUseFactory,
+                // Ensure our service is injected
+                inject: [...(baseOptions.inject || []), FactoryRegistrationService],
+            };
+            this.logger.debug('Created enhanced async ConfigModule options');
+            return enhancedAsyncOptions;
+        }
+        catch (error) {
+            const asyncError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create async ConfigModule options:', asyncError);
+            if (this.options.failOnAwsError) {
+                throw asyncError;
+            }
+            // Return base options if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Falling back to base async ConfigModule options due to AWS error');
+                return baseOptions;
+            }
+            throw asyncError;
+        }
+    }
+    /**
+     * Create a complete ConfigModule with AWS integration.
+     * This method returns a ready-to-use DynamicModule.
+     *
+     * @param baseOptions - Base ConfigModule options
+     * @returns Promise resolving to DynamicModule with AWS integration
+     */
+    async createIntegratedConfigModule(baseOptions = {}) {
+        this.logger.debug('Creating integrated ConfigModule with AWS support');
+        try {
+            // Create enhanced options
+            const enhancedOptions = await this.createConfigModuleOptions(baseOptions);
+            // Create the ConfigModule with enhanced options
+            const configModule = await ConfigModule.forRoot(enhancedOptions);
+            this.logger.log('Created integrated ConfigModule with AWS support');
+            return configModule;
+        }
+        catch (error) {
+            const moduleError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create integrated ConfigModule:', moduleError);
+            if (this.options.failOnAwsError) {
+                throw moduleError;
+            }
+            // Return basic ConfigModule if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Falling back to basic ConfigModule due to AWS error');
+                return await ConfigModule.forRoot(baseOptions);
+            }
+            throw moduleError;
+        }
+    }
+    /**
+     * Create an async integrated ConfigModule.
+     * This method returns a ready-to-use async DynamicModule.
+     *
+     * @param baseOptions - Base async ConfigModule options
+     * @returns Promise resolving to DynamicModule with async AWS integration
+     */
+    async createAsyncIntegratedConfigModule(baseOptions = {}) {
+        this.logger.debug('Creating async integrated ConfigModule with AWS support');
+        try {
+            // Create enhanced options with AWS integration
+            const enhancedOptions = await this.createConfigModuleOptions(baseOptions);
+            // Create the ConfigModule with enhanced options
+            const asyncConfigModule = await ConfigModule.forRoot(enhancedOptions);
+            this.logger.log('Created async integrated ConfigModule with AWS support');
+            return asyncConfigModule;
+        }
+        catch (error) {
+            const asyncModuleError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create async integrated ConfigModule:', asyncModuleError);
+            if (this.options.failOnAwsError) {
+                throw asyncModuleError;
+            }
+            // Return basic async ConfigModule if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Falling back to basic async ConfigModule due to AWS error');
+                return await ConfigModule.forRoot(baseOptions);
+            }
+            throw asyncModuleError;
+        }
+    }
+    /**
+     * Get configuration factories for manual registration.
+     * This method allows developers to manually register AWS factories with their own ConfigModule setup.
+     *
+     * @returns Promise resolving to array of configuration factories
+     */
+    async getConfigurationFactories() {
+        this.logger.debug('Getting configuration factories for manual registration');
+        try {
+            const factories = await this.factoryRegistrationService.registerFactories();
+            this.logger.debug(`Retrieved ${factories.length} configuration factories`);
+            return factories;
+        }
+        catch (error) {
+            const factoryError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get configuration factories:', factoryError);
+            if (this.options.failOnAwsError) {
+                throw factoryError;
+            }
+            // Return empty array if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Returning empty factories array due to AWS error');
+                return [];
+            }
+            throw factoryError;
+        }
+    }
+    /**
+     * Get namespaced configuration factories.
+     * This method returns factories for specific namespaces only.
+     *
+     * @param namespaces - Array of namespace names to get factories for
+     * @returns Promise resolving to array of namespaced configuration factories
+     */
+    async getNamespacedFactories(namespaces) {
+        this.logger.debug(`Getting namespaced factories for: ${namespaces.join(', ')}`);
+        try {
+            const factories = await this.factoryRegistrationService.registerNamespacedFactories(namespaces);
+            this.logger.debug(`Retrieved ${factories.length} namespaced factories`);
+            return factories;
+        }
+        catch (error) {
+            const namespacedError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get namespaced factories:', namespacedError);
+            if (this.options.failOnAwsError) {
+                throw namespacedError;
+            }
+            // Return empty array if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Returning empty namespaced factories array due to AWS error');
+                return [];
+            }
+            throw namespacedError;
+        }
+    }
+    /**
+     * Create a configuration factory for immediate use.
+     * This method creates a single factory that can be used directly with @nestjs/config.
+     *
+     * @param namespace - Optional namespace for the factory
+     * @param config - Optional configuration data to use
+     * @returns Configuration factory
+     */
+    createImmediateFactory(namespace, config) {
+        this.logger.debug(`Creating immediate factory for namespace: ${namespace || 'default'}`);
+        try {
+            const factory = this.factoryRegistrationService.createSyncFactory(namespace, config);
+            this.logger.debug(`Created immediate factory: ${namespace || 'default'}`);
+            return factory;
+        }
+        catch (error) {
+            const immediateError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create immediate factory:', immediateError);
+            if (this.options.failOnAwsError) {
+                throw immediateError;
+            }
+            // Return empty factory if fallback is enabled
+            if (this.options.fallbackToLocal) {
+                this.logger.warn('Creating empty factory due to error');
+                return () => config || {};
+            }
+            throw immediateError;
+        }
+    }
+    /**
+     * Check if AWS integration is available and working.
+     * This method can be used to verify the integration status.
+     *
+     * @returns Promise resolving to integration status
+     */
+    async checkIntegrationStatus() {
+        this.logger.debug('Checking AWS integration status');
+        const status = {
+            isAvailable: false,
+            factoriesRegistered: 0,
+            errors: []
+        };
+        try {
+            // Check if factories are initialized
+            const isInitialized = this.factoryRegistrationService.isFactoriesInitialized();
+            if (isInitialized) {
+                const registeredFactories = this.factoryRegistrationService.getRegisteredFactories();
+                status.factoriesRegistered = registeredFactories.size;
+                status.isAvailable = true;
+            }
+            else {
+                // Try to register factories to check availability
+                const factories = await this.factoryRegistrationService.registerFactories();
+                status.factoriesRegistered = factories.length;
+                status.isAvailable = true;
+            }
+            this.logger.debug(`Integration status: available=${status.isAvailable}, factories=${status.factoriesRegistered}`);
+        }
+        catch (error) {
+            const statusError = error instanceof Error ? error : new Error(String(error));
+            status.errors.push(statusError.message);
+            this.logger.error('Integration status check failed:', statusError);
+        }
+        return status;
+    }
+    /**
+     * Reset the integration state.
+     * This method clears all registered factories and resets the integration.
+     */
+    resetIntegration() {
+        this.logger.debug('Resetting AWS integration state');
+        this.factoryRegistrationService.reset();
+        this.logger.debug('AWS integration state reset complete');
+    }
+};
+NestjsConfigIntegrationService = NestjsConfigIntegrationService_1 = __decorate([
+    Injectable(),
+    __param(1, Optional()),
+    __param(1, Inject(NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS)),
+    __metadata("design:paramtypes", [FactoryRegistrationService, Object])
+], NestjsConfigIntegrationService);
+export { NestjsConfigIntegrationService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nestjs-config-integration.service.js","sourceRoot":"","sources":["../../../../../../src/integration/services/nestjs-config-integration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger, Inject, Optional } from '@nestjs/common';\r\nimport { ConfigFactory, ConfigModule, ConfigModuleOptions } from '@nestjs/config';\r\nimport { DynamicModule } from '@nestjs/common';\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 * Service that provides integration utilities for working with @nestjs/config.\r\n * This service creates ConfigModule configurations that include AWS-sourced factories.\r\n */\r\n@Injectable()\r\nexport class NestjsConfigIntegrationService {\r\n  private readonly logger = new Logger(NestjsConfigIntegrationService.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 a ConfigModule configuration with AWS-sourced factories.\r\n   * This method can be used to enhance existing @nestjs/config setups.\r\n   * \r\n   * @param baseOptions - Base ConfigModule options to enhance\r\n   * @returns Promise resolving to enhanced ConfigModule options\r\n   */\r\n  async createConfigModuleOptions(baseOptions: ConfigModuleOptions = {}): Promise<ConfigModuleOptions> {\r\n    this.logger.debug('Creating ConfigModule options with AWS integration');\r\n    \r\n    try {\r\n      // Register AWS configuration factories\r\n      const awsFactories = await this.factoryRegistrationService.registerFactories();\r\n      \r\n      // Merge AWS factories with existing load array\r\n      const existingLoad = baseOptions.load || [];\r\n      const enhancedLoad = [...existingLoad, ...awsFactories];\r\n      \r\n      // Create enhanced options\r\n      const enhancedOptions: ConfigModuleOptions = {\r\n        ...baseOptions,\r\n        load: enhancedLoad,\r\n        // Apply integration-specific options with proper precedence\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.log(`Enhanced ConfigModule options with ${awsFactories.length} AWS factories`);\r\n      return enhancedOptions;\r\n    } catch (error) {\r\n      const enhancementError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create enhanced ConfigModule options:', enhancementError);\r\n      \r\n      // Handle enhancement failure based on options\r\n      if (this.options.failOnAwsError) {\r\n        throw enhancementError;\r\n      }\r\n      \r\n      // Return base options if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Falling back to base ConfigModule options due to AWS error');\r\n        return baseOptions;\r\n      }\r\n      \r\n      throw enhancementError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a ConfigModule configuration for async setup.\r\n   * This method works with ConfigModule.forRootAsync() pattern.\r\n   * \r\n   * @param baseOptions - Base async ConfigModule options to enhance\r\n   * @returns Promise resolving to enhanced async ConfigModule options\r\n   */\r\n  async createAsyncConfigModuleOptions(baseOptions: any = {}): Promise<any> {\r\n    this.logger.debug('Creating async ConfigModule options with AWS integration');\r\n    \r\n    try {\r\n      // Create a factory function that includes AWS configuration\r\n      const enhancedUseFactory = async (...args: any[]) => {\r\n        // Call original factory if it exists\r\n        let baseConfig: ConfigModuleOptions = {};\r\n        if (baseOptions.useFactory) {\r\n          baseConfig = await baseOptions.useFactory(...args);\r\n        }\r\n        \r\n        // Enhance with AWS configuration\r\n        return await this.createConfigModuleOptions(baseConfig);\r\n      };\r\n      \r\n      // Create enhanced async options\r\n      const enhancedAsyncOptions = {\r\n        ...baseOptions,\r\n        useFactory: enhancedUseFactory,\r\n        // Ensure our service is injected\r\n        inject: [...(baseOptions.inject || []), FactoryRegistrationService],\r\n      };\r\n      \r\n      this.logger.debug('Created enhanced async ConfigModule options');\r\n      return enhancedAsyncOptions;\r\n    } catch (error) {\r\n      const asyncError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create async ConfigModule options:', asyncError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw asyncError;\r\n      }\r\n      \r\n      // Return base options if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Falling back to base async ConfigModule options due to AWS error');\r\n        return baseOptions;\r\n      }\r\n      \r\n      throw asyncError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a complete ConfigModule with AWS integration.\r\n   * This method returns a ready-to-use DynamicModule.\r\n   * \r\n   * @param baseOptions - Base ConfigModule options\r\n   * @returns Promise resolving to DynamicModule with AWS integration\r\n   */\r\n  async createIntegratedConfigModule(baseOptions: ConfigModuleOptions = {}): Promise<DynamicModule> {\r\n    this.logger.debug('Creating integrated ConfigModule with AWS support');\r\n    \r\n    try {\r\n      // Create enhanced options\r\n      const enhancedOptions = await this.createConfigModuleOptions(baseOptions);\r\n      \r\n      // Create the ConfigModule with enhanced options\r\n      const configModule = await ConfigModule.forRoot(enhancedOptions);\r\n      \r\n      this.logger.log('Created integrated ConfigModule with AWS support');\r\n      return configModule;\r\n    } catch (error) {\r\n      const moduleError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create integrated ConfigModule:', moduleError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw moduleError;\r\n      }\r\n      \r\n      // Return basic ConfigModule if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Falling back to basic ConfigModule due to AWS error');\r\n        return await ConfigModule.forRoot(baseOptions);\r\n      }\r\n      \r\n      throw moduleError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create an async integrated ConfigModule.\r\n   * This method returns a ready-to-use async DynamicModule.\r\n   * \r\n   * @param baseOptions - Base async ConfigModule options\r\n   * @returns Promise resolving to DynamicModule with async AWS integration\r\n   */\r\n  async createAsyncIntegratedConfigModule(baseOptions: ConfigModuleOptions = {}): Promise<DynamicModule> {\r\n    this.logger.debug('Creating async integrated ConfigModule with AWS support');\r\n    \r\n    try {\r\n      // Create enhanced options with AWS integration\r\n      const enhancedOptions = await this.createConfigModuleOptions(baseOptions);\r\n      \r\n      // Create the ConfigModule with enhanced options\r\n      const asyncConfigModule = await ConfigModule.forRoot(enhancedOptions);\r\n      \r\n      this.logger.log('Created async integrated ConfigModule with AWS support');\r\n      return asyncConfigModule;\r\n    } catch (error) {\r\n      const asyncModuleError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create async integrated ConfigModule:', asyncModuleError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw asyncModuleError;\r\n      }\r\n      \r\n      // Return basic async ConfigModule if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Falling back to basic async ConfigModule due to AWS error');\r\n        return await ConfigModule.forRoot(baseOptions);\r\n      }\r\n      \r\n      throw asyncModuleError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get configuration factories for manual registration.\r\n   * This method allows developers to manually register AWS factories with their own ConfigModule setup.\r\n   * \r\n   * @returns Promise resolving to array of configuration factories\r\n   */\r\n  async getConfigurationFactories(): Promise<ConfigFactory[]> {\r\n    this.logger.debug('Getting configuration factories for manual registration');\r\n    \r\n    try {\r\n      const factories = await this.factoryRegistrationService.registerFactories();\r\n      this.logger.debug(`Retrieved ${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 get configuration factories:', factoryError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw factoryError;\r\n      }\r\n      \r\n      // Return empty array if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Returning empty factories array 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   * Get namespaced configuration factories.\r\n   * This method returns factories for specific namespaces only.\r\n   * \r\n   * @param namespaces - Array of namespace names to get factories for\r\n   * @returns Promise resolving to array of namespaced configuration factories\r\n   */\r\n  async getNamespacedFactories(namespaces: string[]): Promise<ConfigFactory[]> {\r\n    this.logger.debug(`Getting namespaced factories for: ${namespaces.join(', ')}`);\r\n    \r\n    try {\r\n      const factories = await this.factoryRegistrationService.registerNamespacedFactories(namespaces);\r\n      this.logger.debug(`Retrieved ${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 get namespaced factories:', namespacedError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw namespacedError;\r\n      }\r\n      \r\n      // Return empty array if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Returning empty namespaced factories array due to AWS error');\r\n        return [];\r\n      }\r\n      \r\n      throw namespacedError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a configuration factory for immediate use.\r\n   * This method creates a single factory that can be used directly with @nestjs/config.\r\n   * \r\n   * @param namespace - Optional namespace for the factory\r\n   * @param config - Optional configuration data to use\r\n   * @returns Configuration factory\r\n   */\r\n  createImmediateFactory(namespace?: string, config?: Record<string, any>): ConfigFactory {\r\n    this.logger.debug(`Creating immediate factory for namespace: ${namespace || 'default'}`);\r\n    \r\n    try {\r\n      const factory = this.factoryRegistrationService.createSyncFactory(namespace, config);\r\n      this.logger.debug(`Created immediate factory: ${namespace || 'default'}`);\r\n      return factory;\r\n    } catch (error) {\r\n      const immediateError = error instanceof Error ? error : new Error(String(error));\r\n      this.logger.error('Failed to create immediate factory:', immediateError);\r\n      \r\n      if (this.options.failOnAwsError) {\r\n        throw immediateError;\r\n      }\r\n      \r\n      // Return empty factory if fallback is enabled\r\n      if (this.options.fallbackToLocal) {\r\n        this.logger.warn('Creating empty factory due to error');\r\n        return () => config || {};\r\n      }\r\n      \r\n      throw immediateError;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if AWS integration is available and working.\r\n   * This method can be used to verify the integration status.\r\n   * \r\n   * @returns Promise resolving to integration status\r\n   */\r\n  async checkIntegrationStatus(): Promise<{\r\n    isAvailable: boolean;\r\n    factoriesRegistered: number;\r\n    errors: string[];\r\n  }> {\r\n    this.logger.debug('Checking AWS integration status');\r\n    \r\n    const status = {\r\n      isAvailable: false,\r\n      factoriesRegistered: 0,\r\n      errors: [] as string[]\r\n    };\r\n\r\n    try {\r\n      // Check if factories are initialized\r\n      const isInitialized = this.factoryRegistrationService.isFactoriesInitialized();\r\n      \r\n      if (isInitialized) {\r\n        const registeredFactories = this.factoryRegistrationService.getRegisteredFactories();\r\n        status.factoriesRegistered = registeredFactories.size;\r\n        status.isAvailable = true;\r\n      } else {\r\n        // Try to register factories to check availability\r\n        const factories = await this.factoryRegistrationService.registerFactories();\r\n        status.factoriesRegistered = factories.length;\r\n        status.isAvailable = true;\r\n      }\r\n      \r\n      this.logger.debug(`Integration status: available=${status.isAvailable}, factories=${status.factoriesRegistered}`);\r\n    } catch (error) {\r\n      const statusError = error instanceof Error ? error : new Error(String(error));\r\n      status.errors.push(statusError.message);\r\n      this.logger.error('Integration status check failed:', statusError);\r\n    }\r\n\r\n    return status;\r\n  }\r\n\r\n  /**\r\n   * Reset the integration state.\r\n   * This method clears all registered factories and resets the integration.\r\n   */\r\n  resetIntegration(): void {\r\n    this.logger.debug('Resetting AWS integration state');\r\n    this.factoryRegistrationService.reset();\r\n    this.logger.debug('AWS integration state reset complete');\r\n  }\r\n}"]}