@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/nestjs-config-aws/src/integration/utils/config-integration.util.js

@@ -0,0 +1,240 @@
+import { NestConfigAwsIntegrationModule } from '../nestjs-config-integration.module';
+/**
+ * Utility functions for integrating nestjs-config-aws with @nestjs/config.
+ * These functions provide convenient ways to set up AWS configuration integration.
+ */
+/**
+ * Create a configuration factory that loads from AWS sources.
+ * This factory can be used directly in @nestjs/config's load array.
+ *
+ * @param options - Integration options for AWS configuration
+ * @returns Promise resolving to configuration factory
+ */
+export async function createAwsConfigFactory(options = {}) {
+    // Import services dynamically to avoid circular dependencies
+    const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');
+    const { FactoryRegistrationService } = await import('../services/factory-registration.service');
+    const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');
+    const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');
+    const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');
+    const { NamespaceHandlerService } = await import('../services/namespace-handler.service');
+    const { ValidationIntegrationService } = await import('../services/validation-integration.service');
+    // Create service instances
+    const precedenceHandler = new PrecedenceHandlerService();
+    const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);
+    const awsLoader = new AwsConfigurationLoaderService(options);
+    const namespaceHandler = new NamespaceHandlerService();
+    const validationService = new ValidationIntegrationService();
+    const factoryRegistration = new FactoryRegistrationService(configFactoryProvider, awsLoader, namespaceHandler, validationService, options);
+    const asyncHelper = new AsyncConfigHelperService(factoryRegistration, options);
+    // Create and return the async factory
+    return await asyncHelper.createAsyncConfigFactory();
+}
+/**
+ * Create configuration factories for specific namespaces.
+ * This function creates separate factories for each namespace.
+ *
+ * @param namespaces - Array of namespace names
+ * @param options - Integration options for AWS configuration
+ * @returns Promise resolving to array of namespaced configuration factories
+ */
+export async function createAwsNamespacedFactories(namespaces, options = {}) {
+    // Import services dynamically
+    const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');
+    const { FactoryRegistrationService } = await import('../services/factory-registration.service');
+    const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');
+    const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');
+    const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');
+    const { NamespaceHandlerService } = await import('../services/namespace-handler.service');
+    const { ValidationIntegrationService } = await import('../services/validation-integration.service');
+    // Create service instances
+    const precedenceHandler = new PrecedenceHandlerService();
+    const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);
+    const awsLoader = new AwsConfigurationLoaderService(options);
+    const namespaceHandler = new NamespaceHandlerService();
+    const validationService = new ValidationIntegrationService();
+    const factoryRegistration = new FactoryRegistrationService(configFactoryProvider, awsLoader, namespaceHandler, validationService, options);
+    const asyncHelper = new AsyncConfigHelperService(factoryRegistration, options);
+    // Create and return the namespaced factories
+    return await asyncHelper.createAsyncNamespacedFactories(namespaces);
+}
+/**
+ * Create enhanced ConfigModule options with AWS integration.
+ * This function enhances existing ConfigModule options with AWS-sourced configuration.
+ *
+ * @param baseOptions - Base ConfigModule options to enhance
+ * @param integrationOptions - Integration options for AWS configuration
+ * @returns Promise resolving to enhanced ConfigModule options
+ */
+export async function createEnhancedConfigOptions(baseOptions = {}, integrationOptions = {}) {
+    // Import services dynamically
+    const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');
+    const { FactoryRegistrationService } = await import('../services/factory-registration.service');
+    const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');
+    const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');
+    const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');
+    const { NamespaceHandlerService } = await import('../services/namespace-handler.service');
+    const { ValidationIntegrationService } = await import('../services/validation-integration.service');
+    // Create service instances
+    const precedenceHandler = new PrecedenceHandlerService();
+    const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);
+    const awsLoader = new AwsConfigurationLoaderService(integrationOptions);
+    const namespaceHandler = new NamespaceHandlerService();
+    const validationService = new ValidationIntegrationService();
+    const factoryRegistration = new FactoryRegistrationService(configFactoryProvider, awsLoader, namespaceHandler, validationService, integrationOptions);
+    const asyncHelper = new AsyncConfigHelperService(factoryRegistration, integrationOptions);
+    // Create and return enhanced options
+    return await asyncHelper.createAsyncConfigOptions(baseOptions);
+}
+/**
+ * Create a complete integration module for use with @nestjs/config.
+ * This function returns a module that can be imported alongside ConfigModule.
+ *
+ * @param options - Integration options for AWS configuration
+ * @returns Dynamic module for AWS integration
+ */
+export function createAwsIntegrationModule(options = {}) {
+    return NestConfigAwsIntegrationModule.forRoot(options);
+}
+/**
+ * Create an async integration module for use with @nestjs/config.
+ * This function returns a module that can be imported alongside ConfigModule for async scenarios.
+ *
+ * @param useFactory - Factory function to create integration options
+ * @param inject - Dependencies to inject into the factory function
+ * @param imports - Modules to import for the factory function
+ * @returns Dynamic module for async AWS integration
+ */
+export function createAsyncAwsIntegrationModule(useFactory, inject = [], imports = []) {
+    return NestConfigAwsIntegrationModule.forRootAsync({
+        useFactory,
+        inject,
+        imports,
+    });
+}
+/**
+ * Create a factory function that can be used with ConfigModule.forRoot().
+ * This factory function loads AWS configuration and merges it with local configuration.
+ *
+ * @param integrationOptions - Integration options for AWS configuration
+ * @returns Factory function for use with ConfigModule
+ */
+export function createConfigModuleFactory(integrationOptions = {}) {
+    return async () => {
+        try {
+            // Create AWS configuration factory
+            const awsFactory = await createAwsConfigFactory(integrationOptions);
+            // Return ConfigModule options with AWS factory
+            return {
+                load: [awsFactory],
+                isGlobal: integrationOptions.registerGlobally ?? true,
+                cache: integrationOptions.factoryOptions?.cache ?? true,
+                expandVariables: integrationOptions.factoryOptions?.expandVariables ?? true,
+            };
+        }
+        catch (error) {
+            // Handle error based on integration options
+            if (integrationOptions.failOnAwsError) {
+                throw error;
+            }
+            // Return basic options as fallback
+            if (integrationOptions.fallbackToLocal) {
+                return {
+                    load: [],
+                    isGlobal: integrationOptions.registerGlobally ?? true,
+                    cache: integrationOptions.factoryOptions?.cache ?? true,
+                    expandVariables: integrationOptions.factoryOptions?.expandVariables ?? true,
+                };
+            }
+            throw error;
+        }
+    };
+}
+/**
+ * Create a factory function with dependency injection support.
+ * This factory function can receive injected dependencies and use them to configure AWS integration.
+ *
+ * @param integrationOptions - Integration options for AWS configuration
+ * @param dependencies - Array of dependency tokens to inject
+ * @returns Factory function with dependency injection support
+ */
+export function createConfigModuleFactoryWithDependencies(integrationOptions = {}, dependencies = []) {
+    return async (...injectedDependencies) => {
+        try {
+            // Import services dynamically
+            const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');
+            const { FactoryRegistrationService } = await import('../services/factory-registration.service');
+            const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');
+            const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');
+            const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');
+            const { NamespaceHandlerService } = await import('../services/namespace-handler.service');
+            const { ValidationIntegrationService } = await import('../services/validation-integration.service');
+            // Create service instances
+            const precedenceHandler = new PrecedenceHandlerService();
+            const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);
+            const awsLoader = new AwsConfigurationLoaderService(integrationOptions);
+            const namespaceHandler = new NamespaceHandlerService();
+            const validationService = new ValidationIntegrationService();
+            const factoryRegistration = new FactoryRegistrationService(configFactoryProvider, awsLoader, namespaceHandler, validationService, integrationOptions);
+            const asyncHelper = new AsyncConfigHelperService(factoryRegistration, integrationOptions);
+            // Create factory with dependencies
+            const factoryWithDeps = asyncHelper.createAsyncFactoryWithDependencies(dependencies);
+            // Execute factory with injected dependencies
+            return await factoryWithDeps(...injectedDependencies);
+        }
+        catch (error) {
+            // Handle error based on integration options
+            if (integrationOptions.failOnAwsError) {
+                throw error;
+            }
+            // Return basic options as fallback
+            if (integrationOptions.fallbackToLocal) {
+                return {
+                    load: [],
+                    isGlobal: integrationOptions.registerGlobally ?? true,
+                    cache: integrationOptions.factoryOptions?.cache ?? true,
+                    expandVariables: integrationOptions.factoryOptions?.expandVariables ?? true,
+                };
+            }
+            throw error;
+        }
+    };
+}
+/**
+ * Check if AWS configuration is available for integration.
+ * This function can be used to determine if AWS integration should be enabled.
+ *
+ * @param options - Integration options for AWS configuration
+ * @returns Promise resolving to availability status
+ */
+export async function checkAwsConfigAvailability(options = {}) {
+    try {
+        // Import services dynamically
+        const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');
+        const { FactoryRegistrationService } = await import('../services/factory-registration.service');
+        const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');
+        const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');
+        const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');
+        const { NamespaceHandlerService } = await import('../services/namespace-handler.service');
+        const { ValidationIntegrationService } = await import('../services/validation-integration.service');
+        // Create service instances
+        const precedenceHandler = new PrecedenceHandlerService();
+        const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);
+        const awsLoader = new AwsConfigurationLoaderService(options);
+        const namespaceHandler = new NamespaceHandlerService();
+        const validationService = new ValidationIntegrationService();
+        const factoryRegistration = new FactoryRegistrationService(configFactoryProvider, awsLoader, namespaceHandler, validationService, options);
+        const asyncHelper = new AsyncConfigHelperService(factoryRegistration, options);
+        // Check availability
+        return await asyncHelper.checkAsyncAvailability();
+    }
+    catch (error) {
+        const availabilityError = error instanceof Error ? error : new Error(String(error));
+        return {
+            isAvailable: false,
+            factoriesCount: 0,
+            errors: [availabilityError.message],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-integration.util.js","sourceRoot":"","sources":["../../../../../../src/integration/utils/config-integration.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConfigFactory, ConfigModuleOptions } from '@nestjs/config';\r\nimport { DynamicModule } from '@nestjs/common';\r\nimport { IntegrationOptions } from '../interfaces/integration-options.interface';\r\nimport { NestConfigAwsIntegrationModule } from '../nestjs-config-integration.module';\r\n\r\n/**\r\n * Utility functions for integrating nestjs-config-aws with @nestjs/config.\r\n * These functions provide convenient ways to set up AWS configuration integration.\r\n */\r\n\r\n/**\r\n * Create a configuration factory that loads from AWS sources.\r\n * This factory can be used directly in @nestjs/config's load array.\r\n * \r\n * @param options - Integration options for AWS configuration\r\n * @returns Promise resolving to configuration factory\r\n */\r\nexport async function createAwsConfigFactory(options: IntegrationOptions = {}): Promise<ConfigFactory> {\r\n  // Import services dynamically to avoid circular dependencies\r\n  const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');\r\n  const { FactoryRegistrationService } = await import('../services/factory-registration.service');\r\n  const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');\r\n  const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');\r\n  const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');\r\n  const { NamespaceHandlerService } = await import('../services/namespace-handler.service');\r\n  const { ValidationIntegrationService } = await import('../services/validation-integration.service');\r\n\r\n  // Create service instances\r\n  const precedenceHandler = new PrecedenceHandlerService();\r\n  const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);\r\n  const awsLoader = new AwsConfigurationLoaderService(options);\r\n  const namespaceHandler = new NamespaceHandlerService();\r\n  const validationService = new ValidationIntegrationService();\r\n  const factoryRegistration = new FactoryRegistrationService(\r\n    configFactoryProvider,\r\n    awsLoader,\r\n    namespaceHandler,\r\n    validationService,\r\n    options\r\n  );\r\n  const asyncHelper = new AsyncConfigHelperService(factoryRegistration, options);\r\n\r\n  // Create and return the async factory\r\n  return await asyncHelper.createAsyncConfigFactory();\r\n}\r\n\r\n/**\r\n * Create configuration factories for specific namespaces.\r\n * This function creates separate factories for each namespace.\r\n * \r\n * @param namespaces - Array of namespace names\r\n * @param options - Integration options for AWS configuration\r\n * @returns Promise resolving to array of namespaced configuration factories\r\n */\r\nexport async function createAwsNamespacedFactories(\r\n  namespaces: string[],\r\n  options: IntegrationOptions = {}\r\n): Promise<ConfigFactory[]> {\r\n  // Import services dynamically\r\n  const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');\r\n  const { FactoryRegistrationService } = await import('../services/factory-registration.service');\r\n  const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');\r\n  const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');\r\n  const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');\r\n  const { NamespaceHandlerService } = await import('../services/namespace-handler.service');\r\n  const { ValidationIntegrationService } = await import('../services/validation-integration.service');\r\n\r\n  // Create service instances\r\n  const precedenceHandler = new PrecedenceHandlerService();\r\n  const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);\r\n  const awsLoader = new AwsConfigurationLoaderService(options);\r\n  const namespaceHandler = new NamespaceHandlerService();\r\n  const validationService = new ValidationIntegrationService();\r\n  const factoryRegistration = new FactoryRegistrationService(\r\n    configFactoryProvider,\r\n    awsLoader,\r\n    namespaceHandler,\r\n    validationService,\r\n    options\r\n  );\r\n  const asyncHelper = new AsyncConfigHelperService(factoryRegistration, options);\r\n\r\n  // Create and return the namespaced factories\r\n  return await asyncHelper.createAsyncNamespacedFactories(namespaces);\r\n}\r\n\r\n/**\r\n * Create enhanced ConfigModule options with AWS integration.\r\n * This function enhances existing ConfigModule options with AWS-sourced configuration.\r\n * \r\n * @param baseOptions - Base ConfigModule options to enhance\r\n * @param integrationOptions - Integration options for AWS configuration\r\n * @returns Promise resolving to enhanced ConfigModule options\r\n */\r\nexport async function createEnhancedConfigOptions(\r\n  baseOptions: ConfigModuleOptions = {},\r\n  integrationOptions: IntegrationOptions = {}\r\n): Promise<ConfigModuleOptions> {\r\n  // Import services dynamically\r\n  const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');\r\n  const { FactoryRegistrationService } = await import('../services/factory-registration.service');\r\n  const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');\r\n  const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');\r\n  const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');\r\n  const { NamespaceHandlerService } = await import('../services/namespace-handler.service');\r\n  const { ValidationIntegrationService } = await import('../services/validation-integration.service');\r\n\r\n  // Create service instances\r\n  const precedenceHandler = new PrecedenceHandlerService();\r\n  const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);\r\n  const awsLoader = new AwsConfigurationLoaderService(integrationOptions);\r\n  const namespaceHandler = new NamespaceHandlerService();\r\n  const validationService = new ValidationIntegrationService();\r\n  const factoryRegistration = new FactoryRegistrationService(\r\n    configFactoryProvider,\r\n    awsLoader,\r\n    namespaceHandler,\r\n    validationService,\r\n    integrationOptions\r\n  );\r\n  const asyncHelper = new AsyncConfigHelperService(factoryRegistration, integrationOptions);\r\n\r\n  // Create and return enhanced options\r\n  return await asyncHelper.createAsyncConfigOptions(baseOptions);\r\n}\r\n\r\n/**\r\n * Create a complete integration module for use with @nestjs/config.\r\n * This function returns a module that can be imported alongside ConfigModule.\r\n * \r\n * @param options - Integration options for AWS configuration\r\n * @returns Dynamic module for AWS integration\r\n */\r\nexport function createAwsIntegrationModule(options: IntegrationOptions = {}): DynamicModule {\r\n  return NestConfigAwsIntegrationModule.forRoot(options);\r\n}\r\n\r\n/**\r\n * Create an async integration module for use with @nestjs/config.\r\n * This function returns a module that can be imported alongside ConfigModule for async scenarios.\r\n * \r\n * @param useFactory - Factory function to create integration options\r\n * @param inject - Dependencies to inject into the factory function\r\n * @param imports - Modules to import for the factory function\r\n * @returns Dynamic module for async AWS integration\r\n */\r\nexport function createAsyncAwsIntegrationModule(\r\n  useFactory: (...args: any[]) => Promise<IntegrationOptions> | IntegrationOptions,\r\n  inject: any[] = [],\r\n  imports: any[] = []\r\n): DynamicModule {\r\n  return NestConfigAwsIntegrationModule.forRootAsync({\r\n    useFactory,\r\n    inject,\r\n    imports,\r\n  });\r\n}\r\n\r\n/**\r\n * Create a factory function that can be used with ConfigModule.forRoot().\r\n * This factory function loads AWS configuration and merges it with local configuration.\r\n * \r\n * @param integrationOptions - Integration options for AWS configuration\r\n * @returns Factory function for use with ConfigModule\r\n */\r\nexport function createConfigModuleFactory(\r\n  integrationOptions: IntegrationOptions = {}\r\n): () => Promise<ConfigModuleOptions> {\r\n  return async (): Promise<ConfigModuleOptions> => {\r\n    try {\r\n      // Create AWS configuration factory\r\n      const awsFactory = await createAwsConfigFactory(integrationOptions);\r\n      \r\n      // Return ConfigModule options with AWS factory\r\n      return {\r\n        load: [awsFactory],\r\n        isGlobal: integrationOptions.registerGlobally ?? true,\r\n        cache: integrationOptions.factoryOptions?.cache ?? true,\r\n        expandVariables: integrationOptions.factoryOptions?.expandVariables ?? true,\r\n      };\r\n    } catch (error) {\r\n      // Handle error based on integration options\r\n      if (integrationOptions.failOnAwsError) {\r\n        throw error;\r\n      }\r\n      \r\n      // Return basic options as fallback\r\n      if (integrationOptions.fallbackToLocal) {\r\n        return {\r\n          load: [],\r\n          isGlobal: integrationOptions.registerGlobally ?? true,\r\n          cache: integrationOptions.factoryOptions?.cache ?? true,\r\n          expandVariables: integrationOptions.factoryOptions?.expandVariables ?? true,\r\n        };\r\n      }\r\n      \r\n      throw error;\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * Create a factory function with dependency injection support.\r\n * This factory function can receive injected dependencies and use them to configure AWS integration.\r\n * \r\n * @param integrationOptions - Integration options for AWS configuration\r\n * @param dependencies - Array of dependency tokens to inject\r\n * @returns Factory function with dependency injection support\r\n */\r\nexport function createConfigModuleFactoryWithDependencies(\r\n  integrationOptions: IntegrationOptions = {},\r\n  dependencies: any[] = []\r\n): (...args: any[]) => Promise<ConfigModuleOptions> {\r\n  return async (...injectedDependencies: any[]): Promise<ConfigModuleOptions> => {\r\n    try {\r\n      // Import services dynamically\r\n      const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');\r\n      const { FactoryRegistrationService } = await import('../services/factory-registration.service');\r\n      const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');\r\n      const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');\r\n      const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');\r\n      const { NamespaceHandlerService } = await import('../services/namespace-handler.service');\r\n      const { ValidationIntegrationService } = await import('../services/validation-integration.service');\r\n\r\n      // Create service instances\r\n      const precedenceHandler = new PrecedenceHandlerService();\r\n      const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);\r\n      const awsLoader = new AwsConfigurationLoaderService(integrationOptions);\r\n      const namespaceHandler = new NamespaceHandlerService();\r\n      const validationService = new ValidationIntegrationService();\r\n      const factoryRegistration = new FactoryRegistrationService(\r\n        configFactoryProvider,\r\n        awsLoader,\r\n        namespaceHandler,\r\n        validationService,\r\n        integrationOptions\r\n      );\r\n      const asyncHelper = new AsyncConfigHelperService(factoryRegistration, integrationOptions);\r\n\r\n      // Create factory with dependencies\r\n      const factoryWithDeps = asyncHelper.createAsyncFactoryWithDependencies(dependencies);\r\n      \r\n      // Execute factory with injected dependencies\r\n      return await factoryWithDeps(...injectedDependencies);\r\n    } catch (error) {\r\n      // Handle error based on integration options\r\n      if (integrationOptions.failOnAwsError) {\r\n        throw error;\r\n      }\r\n      \r\n      // Return basic options as fallback\r\n      if (integrationOptions.fallbackToLocal) {\r\n        return {\r\n          load: [],\r\n          isGlobal: integrationOptions.registerGlobally ?? true,\r\n          cache: integrationOptions.factoryOptions?.cache ?? true,\r\n          expandVariables: integrationOptions.factoryOptions?.expandVariables ?? true,\r\n        };\r\n      }\r\n      \r\n      throw error;\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * Check if AWS configuration is available for integration.\r\n * This function can be used to determine if AWS integration should be enabled.\r\n * \r\n * @param options - Integration options for AWS configuration\r\n * @returns Promise resolving to availability status\r\n */\r\nexport async function checkAwsConfigAvailability(\r\n  options: IntegrationOptions = {}\r\n): Promise<{\r\n  isAvailable: boolean;\r\n  factoriesCount: number;\r\n  errors: string[];\r\n}> {\r\n  try {\r\n    // Import services dynamically\r\n    const { AsyncConfigHelperService } = await import('../services/async-config-helper.service');\r\n    const { FactoryRegistrationService } = await import('../services/factory-registration.service');\r\n    const { ConfigurationFactoryProviderImpl } = await import('../providers/configuration-factory.provider');\r\n    const { AwsConfigurationLoaderService } = await import('../providers/aws-configuration-loader.service');\r\n    const { PrecedenceHandlerService } = await import('../services/precedence-handler.service');\r\n    const { NamespaceHandlerService } = await import('../services/namespace-handler.service');\r\n    const { ValidationIntegrationService } = await import('../services/validation-integration.service');\r\n\r\n    // Create service instances\r\n    const precedenceHandler = new PrecedenceHandlerService();\r\n    const configFactoryProvider = new ConfigurationFactoryProviderImpl(precedenceHandler);\r\n    const awsLoader = new AwsConfigurationLoaderService(options);\r\n    const namespaceHandler = new NamespaceHandlerService();\r\n    const validationService = new ValidationIntegrationService();\r\n    const factoryRegistration = new FactoryRegistrationService(\r\n      configFactoryProvider,\r\n      awsLoader,\r\n      namespaceHandler,\r\n      validationService,\r\n      options\r\n    );\r\n    const asyncHelper = new AsyncConfigHelperService(factoryRegistration, options);\r\n\r\n    // Check availability\r\n    return await asyncHelper.checkAsyncAvailability();\r\n  } catch (error) {\r\n    const availabilityError = error instanceof Error ? error : new Error(String(error));\r\n    \r\n    return {\r\n      isAvailable: false,\r\n      factoriesCount: 0,\r\n      errors: [availabilityError.message],\r\n    };\r\n  }\r\n}"]}

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

@@ -0,0 +1,3 @@
+// Integration utilities exports
+export * from './config-integration.util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvaW50ZWdyYXRpb24vdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0NBQWdDO0FBQ2hDLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBJbnRlZ3JhdGlvbiB1dGlsaXRpZXMgZXhwb3J0c1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZy1pbnRlZ3JhdGlvbi51dGlsJzsiXX0=

package/dist/esm/nestjs-config-aws/src/interfaces/config-service.interface.js

@@ -0,0 +1,7 @@
+/**
+ * Abstract ConfigService interface for dependency injection.
+ * Provides type-safe access to configuration values with generic type support.
+ */
+export class ConfigService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2ludGVyZmFjZXMvY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE1BQU0sT0FBZ0IsYUFBYTtDQW1CbEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQWJzdHJhY3QgQ29uZmlnU2VydmljZSBpbnRlcmZhY2UgZm9yIGRlcGVuZGVuY3kgaW5qZWN0aW9uLlxyXG4gKiBQcm92aWRlcyB0eXBlLXNhZmUgYWNjZXNzIHRvIGNvbmZpZ3VyYXRpb24gdmFsdWVzIHdpdGggZ2VuZXJpYyB0eXBlIHN1cHBvcnQuXHJcbiAqL1xyXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQ29uZmlnU2VydmljZTxUID0gYW55PiB7XHJcbiAgLyoqXHJcbiAgICogR2V0IGEgY29uZmlndXJhdGlvbiB2YWx1ZSBieSBrZXkgd2l0aCB0eXBlIHNhZmV0eS5cclxuICAgKiBAcGFyYW0ga2V5IC0gVGhlIGNvbmZpZ3VyYXRpb24ga2V5IHRvIHJldHJpZXZlXHJcbiAgICogQHJldHVybnMgVGhlIGNvbmZpZ3VyYXRpb24gdmFsdWUgd2l0aCBwcm9wZXIgdHlwaW5nXHJcbiAgICovXHJcbiAgYWJzdHJhY3QgZ2V0PEsgZXh0ZW5kcyBrZXlvZiBUPihrZXk6IEspOiBUW0tdO1xyXG5cclxuICAvKipcclxuICAgKiBDaGVjayBpZiB0aGUgY29uZmlndXJhdGlvbiBzZXJ2aWNlIGhhcyBiZWVuIGluaXRpYWxpemVkLlxyXG4gICAqIEByZXR1cm5zIFRydWUgaWYgdGhlIHNlcnZpY2UgaXMgcmVhZHkgdG8gc2VydmUgY29uZmlndXJhdGlvbiB2YWx1ZXNcclxuICAgKi9cclxuICBhYnN0cmFjdCBpc0luaXRpYWxpemVkKCk6IGJvb2xlYW47XHJcblxyXG4gIC8qKlxyXG4gICAqIEdldCBhbGwgY29uZmlndXJhdGlvbiB2YWx1ZXMuXHJcbiAgICogQHJldHVybnMgVGhlIGNvbXBsZXRlIGNvbmZpZ3VyYXRpb24gb2JqZWN0XHJcbiAgICovXHJcbiAgYWJzdHJhY3QgZ2V0QWxsKCk6IFQ7XHJcbn1cclxuIl19

package/dist/esm/nestjs-config-aws/src/interfaces/default-schema.interface.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/**
+ * Default configuration schema using Zod.
+ * Provides a flexible base schema that can be extended by applications.
+ */
+export const defaultConfigSchema = z.object({
+    /** Node.js environment */
+    NODE_ENV: z.enum(['production', 'development', 'test']).optional(),
+    /** Application environment (mirrors NODE_ENV with 'local' default) */
+    APP_ENV: z.enum(['production', 'test', 'development', 'local']).default('local'),
+    /** AWS region for services */
+    AWS_REGION: z.string().optional(),
+    /** AWS profile for local development */
+    AWS_PROFILE: z.string().optional(),
+    /** Application port */
+    PORT: z.coerce.number().positive().optional(),
+    /** Application host */
+    HOST: z.string().optional(),
+    /** Log level */
+    LOG_LEVEL: z.enum(['error', 'warn', 'info', 'debug', 'verbose']).optional(),
+    /** Database URL */
+    DATABASE_URL: z.string().url().optional(),
+    /** Redis URL */
+    REDIS_URL: z.string().url().optional(),
+});
+/**
+ * Environment-specific validation schemas.
+ */
+export const environmentSchemas = {
+    local: defaultConfigSchema.extend({
+        // Local environment may have fewer required fields
+        AWS_REGION: z.string().optional(),
+    }),
+    development: defaultConfigSchema.extend({
+        // Development environment requirements
+        AWS_REGION: z.string().min(1, 'AWS_REGION is required in development'),
+    }),
+    test: defaultConfigSchema.extend({
+        // Test environment requirements
+        AWS_REGION: z.string().min(1, 'AWS_REGION is required in test'),
+    }),
+    production: defaultConfigSchema.extend({
+        // Production environment requirements
+        AWS_REGION: z.string().min(1, 'AWS_REGION is required in production'),
+        LOG_LEVEL: z.enum(['error', 'warn', 'info']).default('info'),
+    }),
+};
+/**
+ * Helper function to get the appropriate schema for the current environment.
+ */
+export function getSchemaForEnvironment(appEnv) {
+    const env = appEnv;
+    return environmentSchemas[env] || defaultConfigSchema;
+}
+/**
+ * Validation helper for APP_ENV values.
+ */
+export const appEnvSchema = z.enum(['production', 'test', 'development', 'local']);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+// Core interfaces
+export * from './config-service.interface';
+export * from './module-options.interface';
+// Error classes - re-export from core for backward compatibility
+export { ConfigurationError, ValidationError, AWSServiceError, ConfigurationLoadError, MissingConfigurationError, } from '@dyanet/config-aws';
+// Default schema and types
+export * from './default-schema.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxrQkFBa0I7QUFDbEIsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDRCQUE0QixDQUFDO0FBRTNDLGlFQUFpRTtBQUNqRSxPQUFPLEVBQ0wsa0JBQWtCLEVBQ2xCLGVBQWUsRUFDZixlQUFlLEVBQ2Ysc0JBQXNCLEVBQ3RCLHlCQUF5QixHQUMxQixNQUFNLG9CQUFvQixDQUFDO0FBRTVCLDJCQUEyQjtBQUMzQixjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29yZSBpbnRlcmZhY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9tb2R1bGUtb3B0aW9ucy5pbnRlcmZhY2UnO1xyXG5cclxuLy8gRXJyb3IgY2xhc3NlcyAtIHJlLWV4cG9ydCBmcm9tIGNvcmUgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHlcclxuZXhwb3J0IHtcclxuICBDb25maWd1cmF0aW9uRXJyb3IsXHJcbiAgVmFsaWRhdGlvbkVycm9yLFxyXG4gIEFXU1NlcnZpY2VFcnJvcixcclxuICBDb25maWd1cmF0aW9uTG9hZEVycm9yLFxyXG4gIE1pc3NpbmdDb25maWd1cmF0aW9uRXJyb3IsXHJcbn0gZnJvbSAnQGR5YW5ldC9jb25maWctYXdzJztcclxuXHJcbi8vIERlZmF1bHQgc2NoZW1hIGFuZCB0eXBlc1xyXG5leHBvcnQgKiBmcm9tICcuL2RlZmF1bHQtc2NoZW1hLmludGVyZmFjZSc7XHJcbiJdfQ==

package/dist/esm/nestjs-config-aws/src/interfaces/module-options.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,139 @@
+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 ConfigServiceImpl_1;
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigManager, ConfigurationError } from '@dyanet/config-aws';
+import { ConfigService } from '../interfaces/config-service.interface';
+/**
+ * NestJS Injectable wrapper around ConfigManager from @dyanet/config-aws.
+ * Provides type-safe configuration access with NestJS dependency injection support.
+ *
+ * This is a thin adapter layer that delegates all configuration loading and
+ * management to the framework-agnostic ConfigManager from config-aws.
+ *
+ * @example
+ * ```typescript
+ * import { ConfigServiceImpl } from '@dyanet/nestjs-config-aws';
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *   DATABASE_URL: z.string(),
+ *   PORT: z.coerce.number().default(3000),
+ * });
+ *
+ * const configService = new ConfigServiceImpl({
+ *   loaders: [new EnvironmentLoader()],
+ *   schema,
+ * });
+ *
+ * await configService.initialize();
+ * const dbUrl = configService.get('DATABASE_URL');
+ * ```
+ */
+let ConfigServiceImpl = ConfigServiceImpl_1 = class ConfigServiceImpl extends ConfigService {
+    logger = new Logger(ConfigServiceImpl_1.name);
+    configManager;
+    enableNestLogging;
+    constructor(options = {}) {
+        super();
+        this.enableNestLogging = options.enableNestLogging ?? true;
+        // Create ConfigManager from config-aws with provided options
+        this.configManager = new ConfigManager({
+            loaders: options.loaders,
+            schema: options.schema,
+            precedence: options.precedence,
+            validateOnLoad: options.validateOnLoad,
+            enableLogging: options.enableLogging,
+            logger: options.logger,
+            verbose: options.verbose,
+        });
+    }
+    /**
+     * Initialize the configuration service by loading configuration from all sources.
+     * This method should be called during application startup.
+     *
+     * @throws ConfigurationError if loading or validation fails
+     */
+    async initialize() {
+        if (this.configManager.isLoaded()) {
+            return;
+        }
+        try {
+            if (this.enableNestLogging) {
+                this.logger.log('Initializing configuration service...');
+            }
+            await this.configManager.load();
+            if (this.enableNestLogging) {
+                this.logger.log('Configuration service initialized successfully');
+            }
+        }
+        catch (error) {
+            const errorMessage = `Failed to initialize configuration service: ${error instanceof Error ? error.message : String(error)}`;
+            this.logger.error(errorMessage);
+            throw error;
+        }
+    }
+    /**
+     * Get a configuration value by key with type safety.
+     *
+     * @param key - The configuration key to retrieve
+     * @returns The configuration value with proper typing
+     * @throws ConfigurationError if configuration is not initialized
+     */
+    get(key) {
+        if (!this.configManager.isLoaded()) {
+            throw new ConfigurationError('Configuration service not initialized. Call initialize() first.');
+        }
+        return this.configManager.get(key);
+    }
+    /**
+     * Check if the configuration service has been initialized.
+     *
+     * @returns True if the service is ready to serve configuration values
+     */
+    isInitialized() {
+        return this.configManager.isLoaded();
+    }
+    /**
+     * Get all configuration values.
+     *
+     * @returns The complete configuration object
+     * @throws ConfigurationError if configuration is not initialized
+     */
+    getAll() {
+        if (!this.configManager.isLoaded()) {
+            throw new ConfigurationError('Configuration service not initialized. Call initialize() first.');
+        }
+        return this.configManager.getAll();
+    }
+    /**
+     * Get the current application environment.
+     *
+     * @returns The APP_ENV value or 'development' as default
+     */
+    getAppEnv() {
+        return this.configManager.getAppEnv();
+    }
+    /**
+     * Get the underlying ConfigManager instance.
+     * Useful for advanced use cases that need direct access to ConfigManager features.
+     *
+     * @returns The ConfigManager instance from @dyanet/config-aws
+     */
+    getConfigManager() {
+        return this.configManager;
+    }
+};
+ConfigServiceImpl = ConfigServiceImpl_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [Object])
+], ConfigServiceImpl);
+export { ConfigServiceImpl };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.service.js","sourceRoot":"","sources":["../../../../../src/services/config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\r\nimport { ConfigManager, ConfigurationError } from '@dyanet/config-aws';\r\nimport type { ConfigManagerOptions } from '@dyanet/config-aws';\r\n\r\nimport { ConfigService } from '../interfaces/config-service.interface';\r\n\r\n/**\r\n * Configuration options for NestJS ConfigService wrapper.\r\n * Extends ConfigManagerOptions from @dyanet/config-aws.\r\n */\r\nexport interface ConfigServiceOptions<T = Record<string, unknown>> extends ConfigManagerOptions<T> {\r\n  /**\r\n   * Whether to enable NestJS logging\r\n   * @default true\r\n   */\r\n  enableNestLogging?: boolean;\r\n}\r\n\r\n/**\r\n * NestJS Injectable wrapper around ConfigManager from @dyanet/config-aws.\r\n * Provides type-safe configuration access with NestJS dependency injection support.\r\n * \r\n * This is a thin adapter layer that delegates all configuration loading and\r\n * management to the framework-agnostic ConfigManager from config-aws.\r\n * \r\n * @example\r\n * ```typescript\r\n * import { ConfigServiceImpl } from '@dyanet/nestjs-config-aws';\r\n * import { z } from 'zod';\r\n * \r\n * const schema = z.object({\r\n *   DATABASE_URL: z.string(),\r\n *   PORT: z.coerce.number().default(3000),\r\n * });\r\n * \r\n * const configService = new ConfigServiceImpl({\r\n *   loaders: [new EnvironmentLoader()],\r\n *   schema,\r\n * });\r\n * \r\n * await configService.initialize();\r\n * const dbUrl = configService.get('DATABASE_URL');\r\n * ```\r\n */\r\n@Injectable()\r\nexport class ConfigServiceImpl<T = Record<string, unknown>> extends ConfigService<T> {\r\n  private readonly logger = new Logger(ConfigServiceImpl.name);\r\n  private readonly configManager: ConfigManager<T>;\r\n  private readonly enableNestLogging: boolean;\r\n\r\n  constructor(options: ConfigServiceOptions<T> = {}) {\r\n    super();\r\n    \r\n    this.enableNestLogging = options.enableNestLogging ?? true;\r\n    \r\n    // Create ConfigManager from config-aws with provided options\r\n    this.configManager = new ConfigManager<T>({\r\n      loaders: options.loaders,\r\n      schema: options.schema,\r\n      precedence: options.precedence,\r\n      validateOnLoad: options.validateOnLoad,\r\n      enableLogging: options.enableLogging,\r\n      logger: options.logger,\r\n      verbose: options.verbose,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Initialize the configuration service by loading configuration from all sources.\r\n   * This method should be called during application startup.\r\n   * \r\n   * @throws ConfigurationError if loading or validation fails\r\n   */\r\n  async initialize(): Promise<void> {\r\n    if (this.configManager.isLoaded()) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      if (this.enableNestLogging) {\r\n        this.logger.log('Initializing configuration service...');\r\n      }\r\n\r\n      await this.configManager.load();\r\n\r\n      if (this.enableNestLogging) {\r\n        this.logger.log('Configuration service initialized successfully');\r\n      }\r\n    } catch (error) {\r\n      const errorMessage = `Failed to initialize configuration service: ${error instanceof Error ? error.message : String(error)}`;\r\n      this.logger.error(errorMessage);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get a configuration value by key with type safety.\r\n   * \r\n   * @param key - The configuration key to retrieve\r\n   * @returns The configuration value with proper typing\r\n   * @throws ConfigurationError if configuration is not initialized\r\n   */\r\n  get<K extends keyof T>(key: K): T[K] {\r\n    if (!this.configManager.isLoaded()) {\r\n      throw new ConfigurationError(\r\n        'Configuration service not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n    return this.configManager.get(key);\r\n  }\r\n\r\n  /**\r\n   * Check if the configuration service has been initialized.\r\n   * \r\n   * @returns True if the service is ready to serve configuration values\r\n   */\r\n  isInitialized(): boolean {\r\n    return this.configManager.isLoaded();\r\n  }\r\n\r\n  /**\r\n   * Get all configuration values.\r\n   * \r\n   * @returns The complete configuration object\r\n   * @throws ConfigurationError if configuration is not initialized\r\n   */\r\n  getAll(): T {\r\n    if (!this.configManager.isLoaded()) {\r\n      throw new ConfigurationError(\r\n        'Configuration service not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n    return this.configManager.getAll();\r\n  }\r\n\r\n  /**\r\n   * Get the current application environment.\r\n   * \r\n   * @returns The APP_ENV value or 'development' as default\r\n   */\r\n  getAppEnv(): string {\r\n    return this.configManager.getAppEnv();\r\n  }\r\n\r\n  /**\r\n   * Get the underlying ConfigManager instance.\r\n   * Useful for advanced use cases that need direct access to ConfigManager features.\r\n   * \r\n   * @returns The ConfigManager instance from @dyanet/config-aws\r\n   */\r\n  getConfigManager(): ConfigManager<T> {\r\n    return this.configManager;\r\n  }\r\n}\r\n"]}