@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

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

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAwsConfigFactory = createAwsConfigFactory;
+exports.createAwsNamespacedFactories = createAwsNamespacedFactories;
+exports.createEnhancedConfigOptions = createEnhancedConfigOptions;
+exports.createAwsIntegrationModule = createAwsIntegrationModule;
+exports.createAsyncAwsIntegrationModule = createAsyncAwsIntegrationModule;
+exports.createConfigModuleFactory = createConfigModuleFactory;
+exports.createConfigModuleFactoryWithDependencies = createConfigModuleFactoryWithDependencies;
+exports.checkAwsConfigAvailability = checkAwsConfigAvailability;
+const nestjs_config_integration_module_1 = require("../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
+ */
+async function createAwsConfigFactory(options = {}) {
+    // Import services dynamically to avoid circular dependencies
+    const { AsyncConfigHelperService } = await Promise.resolve().then(() => __importStar(require('../services/async-config-helper.service')));
+    const { FactoryRegistrationService } = await Promise.resolve().then(() => __importStar(require('../services/factory-registration.service')));
+    const { ConfigurationFactoryProviderImpl } = await Promise.resolve().then(() => __importStar(require('../providers/configuration-factory.provider')));
+    const { AwsConfigurationLoaderService } = await Promise.resolve().then(() => __importStar(require('../providers/aws-configuration-loader.service')));
+    const { PrecedenceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/precedence-handler.service')));
+    const { NamespaceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/namespace-handler.service')));
+    const { ValidationIntegrationService } = await Promise.resolve().then(() => __importStar(require('../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
+ */
+async function createAwsNamespacedFactories(namespaces, options = {}) {
+    // Import services dynamically
+    const { AsyncConfigHelperService } = await Promise.resolve().then(() => __importStar(require('../services/async-config-helper.service')));
+    const { FactoryRegistrationService } = await Promise.resolve().then(() => __importStar(require('../services/factory-registration.service')));
+    const { ConfigurationFactoryProviderImpl } = await Promise.resolve().then(() => __importStar(require('../providers/configuration-factory.provider')));
+    const { AwsConfigurationLoaderService } = await Promise.resolve().then(() => __importStar(require('../providers/aws-configuration-loader.service')));
+    const { PrecedenceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/precedence-handler.service')));
+    const { NamespaceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/namespace-handler.service')));
+    const { ValidationIntegrationService } = await Promise.resolve().then(() => __importStar(require('../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
+ */
+async function createEnhancedConfigOptions(baseOptions = {}, integrationOptions = {}) {
+    // Import services dynamically
+    const { AsyncConfigHelperService } = await Promise.resolve().then(() => __importStar(require('../services/async-config-helper.service')));
+    const { FactoryRegistrationService } = await Promise.resolve().then(() => __importStar(require('../services/factory-registration.service')));
+    const { ConfigurationFactoryProviderImpl } = await Promise.resolve().then(() => __importStar(require('../providers/configuration-factory.provider')));
+    const { AwsConfigurationLoaderService } = await Promise.resolve().then(() => __importStar(require('../providers/aws-configuration-loader.service')));
+    const { PrecedenceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/precedence-handler.service')));
+    const { NamespaceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/namespace-handler.service')));
+    const { ValidationIntegrationService } = await Promise.resolve().then(() => __importStar(require('../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
+ */
+function createAwsIntegrationModule(options = {}) {
+    return nestjs_config_integration_module_1.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
+ */
+function createAsyncAwsIntegrationModule(useFactory, inject = [], imports = []) {
+    return nestjs_config_integration_module_1.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
+ */
+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
+ */
+function createConfigModuleFactoryWithDependencies(integrationOptions = {}, dependencies = []) {
+    return async (...injectedDependencies) => {
+        try {
+            // Import services dynamically
+            const { AsyncConfigHelperService } = await Promise.resolve().then(() => __importStar(require('../services/async-config-helper.service')));
+            const { FactoryRegistrationService } = await Promise.resolve().then(() => __importStar(require('../services/factory-registration.service')));
+            const { ConfigurationFactoryProviderImpl } = await Promise.resolve().then(() => __importStar(require('../providers/configuration-factory.provider')));
+            const { AwsConfigurationLoaderService } = await Promise.resolve().then(() => __importStar(require('../providers/aws-configuration-loader.service')));
+            const { PrecedenceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/precedence-handler.service')));
+            const { NamespaceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/namespace-handler.service')));
+            const { ValidationIntegrationService } = await Promise.resolve().then(() => __importStar(require('../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
+ */
+async function checkAwsConfigAvailability(options = {}) {
+    try {
+        // Import services dynamically
+        const { AsyncConfigHelperService } = await Promise.resolve().then(() => __importStar(require('../services/async-config-helper.service')));
+        const { FactoryRegistrationService } = await Promise.resolve().then(() => __importStar(require('../services/factory-registration.service')));
+        const { ConfigurationFactoryProviderImpl } = await Promise.resolve().then(() => __importStar(require('../providers/configuration-factory.provider')));
+        const { AwsConfigurationLoaderService } = await Promise.resolve().then(() => __importStar(require('../providers/aws-configuration-loader.service')));
+        const { PrecedenceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/precedence-handler.service')));
+        const { NamespaceHandlerService } = await Promise.resolve().then(() => __importStar(require('../services/namespace-handler.service')));
+        const { ValidationIntegrationService } = await Promise.resolve().then(() => __importStar(require('../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/cjs/{integration → nestjs-config-aws/src/integration}/utils/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Integration utilities exports
 __exportStar(require("./config-integration.util"), exports);
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvaW50ZWdyYXRpb24vdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGdDQUFnQztBQUNoQyw0REFBMEMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBJbnRlZ3JhdGlvbiB1dGlsaXRpZXMgZXhwb3J0c1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZy1pbnRlZ3JhdGlvbi51dGlsJzsiXX0=

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+/**
+ * Abstract ConfigService interface for dependency injection.
+ * Provides type-safe access to configuration values with generic type support.
+ */
+class ConfigService {
+}
+exports.ConfigService = ConfigService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2ludGVyZmFjZXMvY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7R0FHRztBQUNILE1BQXNCLGFBQWE7Q0FtQmxDO0FBbkJELHNDQW1CQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBBYnN0cmFjdCBDb25maWdTZXJ2aWNlIGludGVyZmFjZSBmb3IgZGVwZW5kZW5jeSBpbmplY3Rpb24uXHJcbiAqIFByb3ZpZGVzIHR5cGUtc2FmZSBhY2Nlc3MgdG8gY29uZmlndXJhdGlvbiB2YWx1ZXMgd2l0aCBnZW5lcmljIHR5cGUgc3VwcG9ydC5cclxuICovXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBDb25maWdTZXJ2aWNlPFQgPSBhbnk+IHtcclxuICAvKipcclxuICAgKiBHZXQgYSBjb25maWd1cmF0aW9uIHZhbHVlIGJ5IGtleSB3aXRoIHR5cGUgc2FmZXR5LlxyXG4gICAqIEBwYXJhbSBrZXkgLSBUaGUgY29uZmlndXJhdGlvbiBrZXkgdG8gcmV0cmlldmVcclxuICAgKiBAcmV0dXJucyBUaGUgY29uZmlndXJhdGlvbiB2YWx1ZSB3aXRoIHByb3BlciB0eXBpbmdcclxuICAgKi9cclxuICBhYnN0cmFjdCBnZXQ8SyBleHRlbmRzIGtleW9mIFQ+KGtleTogSyk6IFRbS107XHJcblxyXG4gIC8qKlxyXG4gICAqIENoZWNrIGlmIHRoZSBjb25maWd1cmF0aW9uIHNlcnZpY2UgaGFzIGJlZW4gaW5pdGlhbGl6ZWQuXHJcbiAgICogQHJldHVybnMgVHJ1ZSBpZiB0aGUgc2VydmljZSBpcyByZWFkeSB0byBzZXJ2ZSBjb25maWd1cmF0aW9uIHZhbHVlc1xyXG4gICAqL1xyXG4gIGFic3RyYWN0IGlzSW5pdGlhbGl6ZWQoKTogYm9vbGVhbjtcclxuXHJcbiAgLyoqXHJcbiAgICogR2V0IGFsbCBjb25maWd1cmF0aW9uIHZhbHVlcy5cclxuICAgKiBAcmV0dXJucyBUaGUgY29tcGxldGUgY29uZmlndXJhdGlvbiBvYmplY3RcclxuICAgKi9cclxuICBhYnN0cmFjdCBnZXRBbGwoKTogVDtcclxufVxyXG4iXX0=

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingConfigurationError = exports.ConfigurationLoadError = exports.AWSServiceError = exports.ValidationError = exports.ConfigurationError = void 0;
+// Core interfaces
+__exportStar(require("./config-service.interface"), exports);
+__exportStar(require("./module-options.interface"), exports);
+// Error classes - re-export from core for backward compatibility
+var config_aws_1 = require("@dyanet/config-aws");
+Object.defineProperty(exports, "ConfigurationError", { enumerable: true, get: function () { return config_aws_1.ConfigurationError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return config_aws_1.ValidationError; } });
+Object.defineProperty(exports, "AWSServiceError", { enumerable: true, get: function () { return config_aws_1.AWSServiceError; } });
+Object.defineProperty(exports, "ConfigurationLoadError", { enumerable: true, get: function () { return config_aws_1.ConfigurationLoadError; } });
+Object.defineProperty(exports, "MissingConfigurationError", { enumerable: true, get: function () { return config_aws_1.MissingConfigurationError; } });
+// Default schema and types
+__exportStar(require("./default-schema.interface"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGtCQUFrQjtBQUNsQiw2REFBMkM7QUFDM0MsNkRBQTJDO0FBRTNDLGlFQUFpRTtBQUNqRSxpREFNNEI7QUFMMUIsZ0hBQUEsa0JBQWtCLE9BQUE7QUFDbEIsNkdBQUEsZUFBZSxPQUFBO0FBQ2YsNkdBQUEsZUFBZSxPQUFBO0FBQ2Ysb0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIsdUhBQUEseUJBQXlCLE9BQUE7QUFHM0IsMkJBQTJCO0FBQzNCLDZEQUEyQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcmUgaW50ZXJmYWNlc1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZy1zZXJ2aWNlLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kdWxlLW9wdGlvbnMuaW50ZXJmYWNlJztcclxuXHJcbi8vIEVycm9yIGNsYXNzZXMgLSByZS1leHBvcnQgZnJvbSBjb3JlIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5XHJcbmV4cG9ydCB7XHJcbiAgQ29uZmlndXJhdGlvbkVycm9yLFxyXG4gIFZhbGlkYXRpb25FcnJvcixcclxuICBBV1NTZXJ2aWNlRXJyb3IsXHJcbiAgQ29uZmlndXJhdGlvbkxvYWRFcnJvcixcclxuICBNaXNzaW5nQ29uZmlndXJhdGlvbkVycm9yLFxyXG59IGZyb20gJ0BkeWFuZXQvY29uZmlnLWF3cyc7XHJcblxyXG4vLyBEZWZhdWx0IHNjaGVtYSBhbmQgdHlwZXNcclxuZXhwb3J0ICogZnJvbSAnLi9kZWZhdWx0LXNjaGVtYS5pbnRlcmZhY2UnO1xyXG4iXX0=

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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