@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/nestjs-config-aws/src/integration/interfaces/utility-types.interface.js

@@ -0,0 +1,44 @@
+/**
+ * Utility types for enhanced TypeScript support in nest-config-aws integration.
+ */
+/**
+ * Type guard for AWS configuration sources.
+ */
+export const isAwsSource = (source) => {
+    return source === 'secrets-manager' || source === 'ssm';
+};
+/**
+ * Type guard for local configuration sources.
+ */
+export const isLocalSource = (source) => {
+    return source === 'environment' || source === 'local-file';
+};
+/**
+ * Type guard for configuration with metadata.
+ */
+export const hasMetadata = (config) => {
+    return config && typeof config === 'object' && '__metadata' in config;
+};
+/**
+ * Type guard for validation result.
+ */
+export const isValidationResult = (result) => {
+    return (result &&
+        typeof result === 'object' &&
+        'isValid' in result &&
+        typeof result.isValid === 'boolean' &&
+        'errors' in result &&
+        Array.isArray(result.errors));
+};
+/**
+ * Type guard for cache entry.
+ */
+export const isCacheEntry = (entry) => {
+    return (entry &&
+        typeof entry === 'object' &&
+        'key' in entry &&
+        'value' in entry &&
+        'timestamp' in entry &&
+        entry.timestamp instanceof Date);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utility-types.interface.js","sourceRoot":"","sources":["../../../../../../src/integration/interfaces/utility-types.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AAmSH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAAuB,EAA6B,EAAE;IAChF,OAAO,MAAM,KAAK,iBAAiB,IAAI,MAAM,KAAK,KAAK,CAAC;AAC1D,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAuB,EAA+B,EAAE;IACpF,OAAO,MAAM,KAAK,aAAa,IAAI,MAAM,KAAK,YAAY,CAAC;AAC7D,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,MAAW,EACuB,EAAE;IACpC,OAAO,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,YAAY,IAAI,MAAM,CAAC;AACxE,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAI,MAAW,EAAiC,EAAE;IAClF,OAAO,CACL,MAAM;QACN,OAAO,MAAM,KAAK,QAAQ;QAC1B,SAAS,IAAI,MAAM;QACnB,OAAO,MAAM,CAAC,OAAO,KAAK,SAAS;QACnC,QAAQ,IAAI,MAAM;QAClB,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAC7B,CAAC;AACJ,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAI,KAAU,EAA0B,EAAE;IACpE,OAAO,CACL,KAAK;QACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,IAAI,KAAK;QACd,OAAO,IAAI,KAAK;QAChB,WAAW,IAAI,KAAK;QACpB,KAAK,CAAC,SAAS,YAAY,IAAI,CAChC,CAAC;AACJ,CAAC,CAAC","sourcesContent":["/**\r\n * Utility types for enhanced TypeScript support in nest-config-aws integration.\r\n */\r\n\r\n/**\r\n * Deep readonly type for configuration objects.\r\n */\r\nexport type DeepReadonly<T> = {\r\n  readonly [P in keyof T]: T[P] extends (infer U)[]\r\n    ? DeepReadonlyArray<U>\r\n    : T[P] extends object\r\n    ? DeepReadonly<T[P]>\r\n    : T[P];\r\n};\r\n\r\n/**\r\n * Deep readonly array type.\r\n */\r\nexport interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {}\r\n\r\n/**\r\n * Partial deep type for configuration objects.\r\n */\r\nexport type PartialDeep<T> = {\r\n  [P in keyof T]?: T[P] extends (infer U)[]\r\n    ? PartialDeepArray<U>\r\n    : T[P] extends object\r\n    ? PartialDeep<T[P]>\r\n    : T[P];\r\n};\r\n\r\n/**\r\n * Partial deep array type.\r\n */\r\nexport interface PartialDeepArray<T> extends Array<PartialDeep<T>> {}\r\n\r\n/**\r\n * Required deep type for configuration objects.\r\n */\r\nexport type RequiredDeep<T> = {\r\n  [P in keyof T]-?: T[P] extends (infer U)[]\r\n    ? RequiredDeepArray<U>\r\n    : T[P] extends object\r\n    ? RequiredDeep<T[P]>\r\n    : T[P];\r\n};\r\n\r\n/**\r\n * Required deep array type.\r\n */\r\nexport interface RequiredDeepArray<T> extends Array<RequiredDeep<T>> {}\r\n\r\n/**\r\n * Configuration path type for dot notation access.\r\n */\r\nexport type ConfigPath<T, K extends keyof T = keyof T> = K extends string\r\n  ? T[K] extends Record<string, any>\r\n    ? `${K}` | `${K}.${ConfigPath<T[K]>}`\r\n    : `${K}`\r\n  : never;\r\n\r\n/**\r\n * Configuration value type for a given path.\r\n */\r\nexport type ConfigValue<T, P extends string> = P extends `${infer K}.${infer Rest}`\r\n  ? K extends keyof T\r\n    ? ConfigValue<T[K], Rest>\r\n    : never\r\n  : P extends keyof T\r\n  ? T[P]\r\n  : never;\r\n\r\n/**\r\n * AWS configuration source union type.\r\n */\r\nexport type AwsConfigSource = 'secrets-manager' | 'ssm';\r\n\r\n/**\r\n * Local configuration source union type.\r\n */\r\nexport type LocalConfigSource = 'environment' | 'local-file';\r\n\r\n/**\r\n * All configuration source union type.\r\n */\r\nexport type AllConfigSource = AwsConfigSource | LocalConfigSource;\r\n\r\n/**\r\n * Configuration source metadata.\r\n */\r\nexport type ConfigSourceMetadata<T extends AllConfigSource> = {\r\n  source: T;\r\n  isAws: T extends AwsConfigSource ? true : false;\r\n  priority: number;\r\n  loadedAt: Date;\r\n};\r\n\r\n/**\r\n * Configuration with source metadata.\r\n */\r\nexport type ConfigWithSource<T, S extends AllConfigSource> = T & {\r\n  __metadata: ConfigSourceMetadata<S>;\r\n};\r\n\r\n/**\r\n * Extract configuration type from a configuration factory.\r\n */\r\nexport type ExtractConfig<T> = T extends () => infer U ? U : never;\r\n\r\n/**\r\n * Configuration factory map type.\r\n */\r\nexport type ConfigFactoryMap = Record<string, () => any>;\r\n\r\n/**\r\n * Extract all configuration types from a factory map.\r\n */\r\nexport type ExtractConfigMap<T extends ConfigFactoryMap> = {\r\n  [K in keyof T]: ExtractConfig<T[K]>;\r\n};\r\n\r\n/**\r\n * Namespace configuration type.\r\n */\r\nexport type NamespaceConfig<T extends Record<string, any>> = {\r\n  [K in keyof T]: T[K];\r\n};\r\n\r\n/**\r\n * Multi-namespace configuration type.\r\n */\r\nexport type MultiNamespaceConfig<T extends Record<string, Record<string, any>>> = {\r\n  [K in keyof T]: NamespaceConfig<T[K]>;\r\n};\r\n\r\n/**\r\n * Configuration validation result.\r\n */\r\nexport type ValidationResult<T = any> = {\r\n  isValid: boolean;\r\n  data?: T;\r\n  errors: string[];\r\n};\r\n\r\n/**\r\n * Async configuration validation result.\r\n */\r\nexport type AsyncValidationResult<T = any> = Promise<ValidationResult<T>>;\r\n\r\n/**\r\n * Configuration transformer function type.\r\n */\r\nexport type ConfigTransformerFn<TInput, TOutput> = (input: TInput) => TOutput;\r\n\r\n/**\r\n * Async configuration transformer function type.\r\n */\r\nexport type AsyncConfigTransformerFn<TInput, TOutput> = (input: TInput) => Promise<TOutput>;\r\n\r\n/**\r\n * Configuration predicate function type.\r\n */\r\nexport type ConfigPredicate<T> = (config: T) => boolean;\r\n\r\n/**\r\n * Async configuration predicate function type.\r\n */\r\nexport type AsyncConfigPredicate<T> = (config: T) => Promise<boolean>;\r\n\r\n/**\r\n * Configuration key extractor type.\r\n */\r\nexport type ConfigKeyExtractor<T> = (config: T) => string[];\r\n\r\n/**\r\n * Configuration value extractor type.\r\n */\r\nexport type ConfigValueExtractor<T, U> = (config: T, key: string) => U | undefined;\r\n\r\n/**\r\n * Configuration merger function type.\r\n */\r\nexport type ConfigMerger<T> = (primary: T, secondary: T) => T;\r\n\r\n/**\r\n * Configuration serializer function type.\r\n */\r\nexport type ConfigSerializer<T> = (config: T) => string;\r\n\r\n/**\r\n * Configuration deserializer function type.\r\n */\r\nexport type ConfigDeserializer<T> = (serialized: string) => T;\r\n\r\n/**\r\n * Configuration cache key generator type.\r\n */\r\nexport type CacheKeyGenerator<T> = (config: T) => string;\r\n\r\n/**\r\n * Configuration cache entry type.\r\n */\r\nexport type CacheEntry<T> = {\r\n  key: string;\r\n  value: T;\r\n  timestamp: Date;\r\n  ttl?: number;\r\n};\r\n\r\n/**\r\n * Configuration cache type.\r\n */\r\nexport type ConfigCache<T> = Map<string, CacheEntry<T>>;\r\n\r\n/**\r\n * Configuration event type.\r\n */\r\nexport type ConfigEventType = 'loaded' | 'updated' | 'error' | 'validated';\r\n\r\n/**\r\n * Configuration event handler type.\r\n */\r\nexport type ConfigEventHandler<T = any> = (event: ConfigEventType, data: T) => void;\r\n\r\n/**\r\n * Async configuration event handler type.\r\n */\r\nexport type AsyncConfigEventHandler<T = any> = (event: ConfigEventType, data: T) => Promise<void>;\r\n\r\n/**\r\n * Configuration watcher type.\r\n */\r\nexport type ConfigWatcher<T> = {\r\n  watch: (handler: ConfigEventHandler<T>) => void;\r\n  unwatch: (handler: ConfigEventHandler<T>) => void;\r\n  stop: () => void;\r\n};\r\n\r\n/**\r\n * Configuration builder pattern interface.\r\n */\r\nexport interface ConfigBuilder<T> {\r\n  /**\r\n   * Add a configuration source.\r\n   */\r\n  addSource(source: AllConfigSource, config: any): ConfigBuilder<T>;\r\n\r\n  /**\r\n   * Set precedence rule.\r\n   */\r\n  setPrecedence(rule: 'aws-first' | 'local-first' | 'merge'): ConfigBuilder<T>;\r\n\r\n  /**\r\n   * Add namespace.\r\n   */\r\n  addNamespace(namespace: string): ConfigBuilder<T>;\r\n\r\n  /**\r\n   * Add validation.\r\n   */\r\n  addValidation(validator: (config: any) => boolean): ConfigBuilder<T>;\r\n\r\n  /**\r\n   * Build the configuration.\r\n   */\r\n  build(): T;\r\n}\r\n\r\n/**\r\n * Configuration fluent API interface.\r\n */\r\nexport interface ConfigFluentAPI<T> {\r\n  /**\r\n   * Filter configuration by predicate.\r\n   */\r\n  filter(predicate: ConfigPredicate<T>): ConfigFluentAPI<T>;\r\n\r\n  /**\r\n   * Transform configuration.\r\n   */\r\n  map<U>(transformer: ConfigTransformerFn<T, U>): ConfigFluentAPI<U>;\r\n\r\n  /**\r\n   * Validate configuration.\r\n   */\r\n  validate(validator: ConfigPredicate<T>): ConfigFluentAPI<T>;\r\n\r\n  /**\r\n   * Get the final configuration.\r\n   */\r\n  get(): T;\r\n}\r\n\r\n/**\r\n * Type guard for AWS configuration sources.\r\n */\r\nexport const isAwsSource = (source: AllConfigSource): source is AwsConfigSource => {\r\n  return source === 'secrets-manager' || source === 'ssm';\r\n};\r\n\r\n/**\r\n * Type guard for local configuration sources.\r\n */\r\nexport const isLocalSource = (source: AllConfigSource): source is LocalConfigSource => {\r\n  return source === 'environment' || source === 'local-file';\r\n};\r\n\r\n/**\r\n * Type guard for configuration with metadata.\r\n */\r\nexport const hasMetadata = <T, S extends AllConfigSource>(\r\n  config: any\r\n): config is ConfigWithSource<T, S> => {\r\n  return config && typeof config === 'object' && '__metadata' in config;\r\n};\r\n\r\n/**\r\n * Type guard for validation result.\r\n */\r\nexport const isValidationResult = <T>(result: any): result is ValidationResult<T> => {\r\n  return (\r\n    result &&\r\n    typeof result === 'object' &&\r\n    'isValid' in result &&\r\n    typeof result.isValid === 'boolean' &&\r\n    'errors' in result &&\r\n    Array.isArray(result.errors)\r\n  );\r\n};\r\n\r\n/**\r\n * Type guard for cache entry.\r\n */\r\nexport const isCacheEntry = <T>(entry: any): entry is CacheEntry<T> => {\r\n  return (\r\n    entry &&\r\n    typeof entry === 'object' &&\r\n    'key' in entry &&\r\n    'value' in entry &&\r\n    'timestamp' in entry &&\r\n    entry.timestamp instanceof Date\r\n  );\r\n};"]}

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

@@ -0,0 +1,121 @@
+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 NestConfigAwsIntegrationModule_1;
+import { Global, Module } from '@nestjs/common';
+import { ConfigurationFactoryProviderImpl } from './providers/configuration-factory.provider';
+import { AwsConfigurationLoaderService } from './providers/aws-configuration-loader.service';
+import { IntegrationStateService } from './services/integration-state.service';
+import { FactoryRegistrationService } from './services/factory-registration.service';
+import { NestjsConfigIntegrationService } from './services/nestjs-config-integration.service';
+import { PrecedenceHandlerService } from './services/precedence-handler.service';
+import { AsyncConfigHelperService } from './services/async-config-helper.service';
+import { NamespaceHandlerService } from './services/namespace-handler.service';
+import { ValidationIntegrationService } from './services/validation-integration.service';
+/**
+ * Token for injecting integration options
+ */
+export const NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS = 'NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS';
+/**
+ * NestJS module for integrating nestjs-config-aws with @nestjs/config.
+ * This module provides AWS-sourced configuration values to the standard @nestjs/config module.
+ */
+let NestConfigAwsIntegrationModule = NestConfigAwsIntegrationModule_1 = class NestConfigAwsIntegrationModule {
+    /**
+     * Create a synchronous integration module with provided options.
+     *
+     * @param options - Integration options for the module
+     * @returns Dynamic module configuration
+     */
+    static forRoot(options = {}) {
+        const providers = this.createProviders(options);
+        return {
+            module: NestConfigAwsIntegrationModule_1,
+            providers: [
+                {
+                    provide: NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS,
+                    useValue: options,
+                },
+                ...providers,
+            ],
+            exports: [
+                ConfigurationFactoryProviderImpl,
+                AwsConfigurationLoaderService,
+                IntegrationStateService,
+                FactoryRegistrationService,
+                NestjsConfigIntegrationService,
+                AsyncConfigHelperService,
+                NamespaceHandlerService,
+                ValidationIntegrationService,
+            ],
+            global: options.registerGlobally !== false,
+        };
+    }
+    /**
+     * Create an asynchronous integration module with factory-based options.
+     * Useful when integration options depend on other services or async operations.
+     *
+     * @param options - Async integration options with factory function
+     * @returns Dynamic module configuration
+     */
+    static forRootAsync(options) {
+        const asyncProviders = this.createAsyncProviders(options);
+        const providers = this.createProviders();
+        return {
+            module: NestConfigAwsIntegrationModule_1,
+            imports: options.imports || [],
+            providers: [
+                ...asyncProviders,
+                ...providers,
+            ],
+            exports: [
+                ConfigurationFactoryProviderImpl,
+                AwsConfigurationLoaderService,
+                IntegrationStateService,
+                FactoryRegistrationService,
+                NestjsConfigIntegrationService,
+                AsyncConfigHelperService,
+                NamespaceHandlerService,
+                ValidationIntegrationService,
+            ],
+            global: true, // Default to global for async modules
+        };
+    }
+    /**
+     * Create the standard providers for the integration module.
+     */
+    static createProviders(_options) {
+        return [
+            ConfigurationFactoryProviderImpl,
+            AwsConfigurationLoaderService,
+            IntegrationStateService,
+            PrecedenceHandlerService,
+            FactoryRegistrationService,
+            NestjsConfigIntegrationService,
+            AsyncConfigHelperService,
+            NamespaceHandlerService,
+            ValidationIntegrationService,
+        ];
+    }
+    /**
+     * Create providers for asynchronous module registration.
+     */
+    static createAsyncProviders(options) {
+        return [
+            {
+                provide: NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            },
+        ];
+    }
+};
+NestConfigAwsIntegrationModule = NestConfigAwsIntegrationModule_1 = __decorate([
+    Global(),
+    Module({})
+], NestConfigAwsIntegrationModule);
+export { NestConfigAwsIntegrationModule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nestjs-config-integration.module.js","sourceRoot":"","sources":["../../../../../src/integration/nestjs-config-integration.module.ts"],"names":[],"mappings":";;;;;;;AAAA,OAAO,EAAiB,MAAM,EAAE,MAAM,EAAY,MAAM,gBAAgB,CAAC;AAEzE,OAAO,EAAE,gCAAgC,EAAE,MAAM,4CAA4C,CAAC;AAC9F,OAAO,EAAE,6BAA6B,EAAE,MAAM,8CAA8C,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,8BAA8B,EAAE,MAAM,8CAA8C,CAAC;AAC9F,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AAEzF;;GAEG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,uCAAuC,CAAC;AAE7F;;;GAGG;AAGI,IAAM,8BAA8B,sCAApC,MAAM,8BAA8B;IACzC;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,UAA8B,EAAE;QAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAEhD,OAAO;YACL,MAAM,EAAE,gCAA8B;YACtC,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,qCAAqC;oBAC9C,QAAQ,EAAE,OAAO;iBAClB;gBACD,GAAG,SAAS;aACb;YACD,OAAO,EAAE;gBACP,gCAAgC;gBAChC,6BAA6B;gBAC7B,uBAAuB;gBACvB,0BAA0B;gBAC1B,8BAA8B;gBAC9B,wBAAwB;gBACxB,uBAAuB;gBACvB,4BAA4B;aAC7B;YACD,MAAM,EAAE,OAAO,CAAC,gBAAgB,KAAK,KAAK;SAC3C,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CAAC,OAAgC;QAClD,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAC1D,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAEzC,OAAO;YACL,MAAM,EAAE,gCAA8B;YACtC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;YAC9B,SAAS,EAAE;gBACT,GAAG,cAAc;gBACjB,GAAG,SAAS;aACb;YACD,OAAO,EAAE;gBACP,gCAAgC;gBAChC,6BAA6B;gBAC7B,uBAAuB;gBACvB,0BAA0B;gBAC1B,8BAA8B;gBAC9B,wBAAwB;gBACxB,uBAAuB;gBACvB,4BAA4B;aAC7B;YACD,MAAM,EAAE,IAAI,EAAE,sCAAsC;SACrD,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,eAAe,CAAC,QAA6B;QAC1D,OAAO;YACL,gCAAgC;YAChC,6BAA6B;YAC7B,uBAAuB;YACvB,wBAAwB;YACxB,0BAA0B;YAC1B,8BAA8B;YAC9B,wBAAwB;YACxB,uBAAuB;YACvB,4BAA4B;SAC7B,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,oBAAoB,CAAC,OAAgC;QAClE,OAAO;YACL;gBACE,OAAO,EAAE,qCAAqC;gBAC9C,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE;aAC7B;SACF,CAAC;IACJ,CAAC;CACF,CAAA;AA9FY,8BAA8B;IAF1C,MAAM,EAAE;IACR,MAAM,CAAC,EAAE,CAAC;GACE,8BAA8B,CA8F1C","sourcesContent":["import { DynamicModule, Global, Module, Provider } from '@nestjs/common';\r\nimport { IntegrationOptions, AsyncIntegrationOptions } from './interfaces/integration-options.interface';\r\nimport { ConfigurationFactoryProviderImpl } from './providers/configuration-factory.provider';\r\nimport { AwsConfigurationLoaderService } from './providers/aws-configuration-loader.service';\r\nimport { IntegrationStateService } from './services/integration-state.service';\r\nimport { FactoryRegistrationService } from './services/factory-registration.service';\r\nimport { NestjsConfigIntegrationService } from './services/nestjs-config-integration.service';\r\nimport { PrecedenceHandlerService } from './services/precedence-handler.service';\r\nimport { AsyncConfigHelperService } from './services/async-config-helper.service';\r\nimport { NamespaceHandlerService } from './services/namespace-handler.service';\r\nimport { ValidationIntegrationService } from './services/validation-integration.service';\r\n\r\n/**\r\n * Token for injecting integration options\r\n */\r\nexport const NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS = 'NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS';\r\n\r\n/**\r\n * NestJS module for integrating nestjs-config-aws with @nestjs/config.\r\n * This module provides AWS-sourced configuration values to the standard @nestjs/config module.\r\n */\r\n@Global()\r\n@Module({})\r\nexport class NestConfigAwsIntegrationModule {\r\n  /**\r\n   * Create a synchronous integration module with provided options.\r\n   * \r\n   * @param options - Integration options for the module\r\n   * @returns Dynamic module configuration\r\n   */\r\n  static forRoot(options: IntegrationOptions = {}): DynamicModule {\r\n    const providers = this.createProviders(options);\r\n\r\n    return {\r\n      module: NestConfigAwsIntegrationModule,\r\n      providers: [\r\n        {\r\n          provide: NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS,\r\n          useValue: options,\r\n        },\r\n        ...providers,\r\n      ],\r\n      exports: [\r\n        ConfigurationFactoryProviderImpl,\r\n        AwsConfigurationLoaderService,\r\n        IntegrationStateService,\r\n        FactoryRegistrationService,\r\n        NestjsConfigIntegrationService,\r\n        AsyncConfigHelperService,\r\n        NamespaceHandlerService,\r\n        ValidationIntegrationService,\r\n      ],\r\n      global: options.registerGlobally !== false,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create an asynchronous integration module with factory-based options.\r\n   * Useful when integration options depend on other services or async operations.\r\n   * \r\n   * @param options - Async integration options with factory function\r\n   * @returns Dynamic module configuration\r\n   */\r\n  static forRootAsync(options: AsyncIntegrationOptions): DynamicModule {\r\n    const asyncProviders = this.createAsyncProviders(options);\r\n    const providers = this.createProviders();\r\n\r\n    return {\r\n      module: NestConfigAwsIntegrationModule,\r\n      imports: options.imports || [],\r\n      providers: [\r\n        ...asyncProviders,\r\n        ...providers,\r\n      ],\r\n      exports: [\r\n        ConfigurationFactoryProviderImpl,\r\n        AwsConfigurationLoaderService,\r\n        IntegrationStateService,\r\n        FactoryRegistrationService,\r\n        NestjsConfigIntegrationService,\r\n        AsyncConfigHelperService,\r\n        NamespaceHandlerService,\r\n        ValidationIntegrationService,\r\n      ],\r\n      global: true, // Default to global for async modules\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create the standard providers for the integration module.\r\n   */\r\n  private static createProviders(_options?: IntegrationOptions): Provider[] {\r\n    return [\r\n      ConfigurationFactoryProviderImpl,\r\n      AwsConfigurationLoaderService,\r\n      IntegrationStateService,\r\n      PrecedenceHandlerService,\r\n      FactoryRegistrationService,\r\n      NestjsConfigIntegrationService,\r\n      AsyncConfigHelperService,\r\n      NamespaceHandlerService,\r\n      ValidationIntegrationService,\r\n    ];\r\n  }\r\n\r\n  /**\r\n   * Create providers for asynchronous module registration.\r\n   */\r\n  private static createAsyncProviders(options: AsyncIntegrationOptions): Provider[] {\r\n    return [\r\n      {\r\n        provide: NESTJS_CONFIG_AWS_INTEGRATION_OPTIONS,\r\n        useFactory: options.useFactory,\r\n        inject: options.inject || [],\r\n      },\r\n    ];\r\n  }\r\n}"]}