@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

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

@@ -0,0 +1,81 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationStateService = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Service for managing the state of the integration module.
+ */
+let IntegrationStateService = class IntegrationStateService {
+    state = {
+        isInitialized: false,
+        awsAvailable: false,
+        loadedSources: [],
+        registeredFactories: [],
+        errors: [],
+    };
+    /**
+     * Get the current integration state.
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Mark the integration as initialized.
+     */
+    setInitialized(initialized) {
+        this.state.isInitialized = initialized;
+    }
+    /**
+     * Set AWS availability status.
+     */
+    setAwsAvailable(available) {
+        this.state.awsAvailable = available;
+    }
+    /**
+     * Add a loaded configuration source.
+     */
+    addLoadedSource(source) {
+        this.state.loadedSources.push(source);
+    }
+    /**
+     * Add a registered factory name.
+     */
+    addRegisteredFactory(factoryName) {
+        this.state.registeredFactories.push(factoryName);
+    }
+    /**
+     * Add an error to the state.
+     */
+    addError(error) {
+        this.state.errors.push(error);
+    }
+    /**
+     * Clear all errors.
+     */
+    clearErrors() {
+        this.state.errors = [];
+    }
+    /**
+     * Reset the integration state.
+     */
+    reset() {
+        this.state = {
+            isInitialized: false,
+            awsAvailable: false,
+            loadedSources: [],
+            registeredFactories: [],
+            errors: [],
+        };
+    }
+};
+exports.IntegrationStateService = IntegrationStateService;
+exports.IntegrationStateService = IntegrationStateService = __decorate([
+    (0, common_1.Injectable)()
+], IntegrationStateService);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/nestjs-config-aws/src/integration/services/namespace-handler.service.js

@@ -0,0 +1,465 @@
+"use strict";
+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 NamespaceHandlerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceHandlerService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+/**
+ * Service for handling namespace-aware configuration loading and factory creation.
+ * Provides enhanced namespace support for @nestjs/config integration.
+ */
+let NamespaceHandlerService = NamespaceHandlerService_1 = class NamespaceHandlerService {
+    logger = new common_1.Logger(NamespaceHandlerService_1.name);
+    /**
+     * Create a registerAs factory for a specific namespace.
+     * This method creates a factory that can be used with @nestjs/config's registerAs pattern.
+     *
+     * @param namespace - The namespace for the configuration
+     * @param config - The configuration data for the namespace
+     * @param sources - Optional configuration sources metadata
+     * @returns A registerAs factory for the namespace
+     */
+    createNamespaceFactory(namespace, config, sources) {
+        this.logger.debug(`Creating namespace factory for: ${namespace}`);
+        // Validate namespace
+        if (!this.isValidNamespace(namespace)) {
+            throw new Error(`Invalid namespace: ${namespace}`);
+        }
+        // Create the factory function
+        const factory = () => {
+            this.logger.debug(`Namespace factory called for: ${namespace}`);
+            // Process and validate configuration
+            const processedConfig = this.processNamespaceConfig(config, namespace);
+            this.logger.debug(`Namespace factory returning ${Object.keys(processedConfig).length} keys for: ${namespace}`);
+            return processedConfig;
+        };
+        // Create registerAs factory
+        const namespacedFactory = (0, config_1.registerAs)(namespace, factory);
+        // Add metadata for introspection and debugging
+        this.addFactoryMetadata(namespacedFactory, namespace, config, sources);
+        return namespacedFactory;
+    }
+    /**
+     * Create multiple namespace factories from configuration data.
+     *
+     * @param namespacedConfig - Configuration data organized by namespace
+     * @param sources - Optional configuration sources metadata
+     * @returns Array of namespace factories
+     */
+    createMultipleNamespaceFactories(namespacedConfig, sources) {
+        this.logger.debug(`Creating multiple namespace factories for: ${Object.keys(namespacedConfig).join(', ')}`);
+        const factories = [];
+        for (const [namespace, config] of Object.entries(namespacedConfig)) {
+            if (this.isValidNamespaceConfig(namespace, config)) {
+                try {
+                    const namespaceSources = sources?.filter(s => s.namespace === namespace ||
+                        s.data[namespace] !== undefined);
+                    const factory = this.createNamespaceFactory(namespace, config, namespaceSources);
+                    factories.push(factory);
+                    this.logger.debug(`Created namespace factory for: ${namespace}`);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to create namespace factory for ${namespace}:`, error);
+                }
+            }
+            else {
+                this.logger.warn(`Skipping invalid namespace configuration: ${namespace}`);
+            }
+        }
+        this.logger.debug(`Created ${factories.length} namespace factories`);
+        return factories;
+    }
+    /**
+     * Extract namespace configuration from flat configuration using various strategies.
+     *
+     * @param config - Flat configuration object
+     * @param namespace - Target namespace
+     * @returns Configuration for the namespace
+     */
+    extractNamespaceConfig(config, namespace) {
+        const namespaceConfig = {};
+        // Strategy 1: Direct namespace key (e.g., config.database)
+        if (config[namespace] && typeof config[namespace] === 'object') {
+            Object.assign(namespaceConfig, config[namespace]);
+        }
+        // Strategy 2: Prefixed keys (e.g., DATABASE_HOST -> host)
+        const prefixedConfig = this.extractPrefixedConfig(config, namespace);
+        Object.assign(namespaceConfig, prefixedConfig);
+        // Strategy 3: Path-based keys (e.g., /app/database/host -> host)
+        const pathConfig = this.extractPathBasedConfig(config, namespace);
+        Object.assign(namespaceConfig, pathConfig);
+        return namespaceConfig;
+    }
+    /**
+     * Organize flat configuration into namespaces based on patterns.
+     *
+     * @param config - Flat configuration object
+     * @param namespaces - List of target namespaces
+     * @returns Configuration organized by namespace
+     */
+    organizeConfigByNamespaces(config, namespaces) {
+        const organized = {};
+        // Initialize all namespaces
+        for (const namespace of namespaces) {
+            organized[namespace] = {};
+        }
+        // Extract configuration for each namespace
+        for (const namespace of namespaces) {
+            organized[namespace] = this.extractNamespaceConfig(config, namespace);
+        }
+        // Handle remaining configuration that doesn't match any namespace
+        const remainingConfig = this.extractRemainingConfig(config, namespaces);
+        if (Object.keys(remainingConfig).length > 0) {
+            organized['default'] = remainingConfig;
+        }
+        return organized;
+    }
+    /**
+     * Validate namespace access patterns for @nestjs/config compatibility.
+     *
+     * @param namespace - Namespace to validate
+     * @param config - Configuration for the namespace
+     * @returns Validation result with suggestions
+     */
+    validateNamespaceAccess(namespace, config) {
+        const issues = [];
+        const suggestions = [];
+        // Check namespace name validity
+        if (!this.isValidNamespace(namespace)) {
+            issues.push(`Invalid namespace name: ${namespace}`);
+            suggestions.push('Use alphanumeric characters and underscores only');
+        }
+        // Check for reserved namespace names
+        if (this.isReservedNamespace(namespace)) {
+            issues.push(`Reserved namespace name: ${namespace}`);
+            suggestions.push('Choose a different namespace name');
+        }
+        // Check configuration structure
+        if (!this.isValidNamespaceConfig(namespace, config)) {
+            issues.push('Invalid configuration structure for namespace');
+            suggestions.push('Ensure configuration is a non-empty object');
+        }
+        // Check for potential key conflicts
+        const conflicts = this.findKeyConflicts(config);
+        if (conflicts.length > 0) {
+            issues.push(`Key conflicts found: ${conflicts.join(', ')}`);
+            suggestions.push('Resolve key naming conflicts');
+        }
+        return {
+            isValid: issues.length === 0,
+            issues,
+            suggestions
+        };
+    }
+    /**
+     * Generate access patterns documentation for a namespace.
+     *
+     * @param namespace - Namespace name
+     * @param config - Configuration for the namespace
+     * @returns Access patterns documentation
+     */
+    generateAccessPatterns(namespace, config) {
+        const patterns = {
+            injection: `@Inject(${namespace}Config.KEY)`,
+            service: `this.configService.get('${namespace}')`,
+            direct: `this.configService.get('${namespace}.key')`
+        };
+        const examples = this.generateUsageExamples(namespace, config);
+        return {
+            namespace,
+            patterns,
+            examples
+        };
+    }
+    /**
+     * Process namespace configuration with validation and transformation.
+     *
+     * @param config - Raw configuration for the namespace
+     * @param namespace - Namespace name
+     * @returns Processed configuration
+     */
+    processNamespaceConfig(config, namespace) {
+        // Deep clone to avoid mutations
+        const processed = JSON.parse(JSON.stringify(config));
+        // Apply transformations
+        this.transformConfigValues(processed);
+        // Validate processed configuration
+        this.validateProcessedConfig(processed, namespace);
+        return processed;
+    }
+    /**
+     * Extract configuration using prefix patterns.
+     *
+     * @param config - Source configuration
+     * @param namespace - Target namespace
+     * @returns Prefixed configuration
+     */
+    extractPrefixedConfig(config, namespace) {
+        const prefixedConfig = {};
+        const prefix = namespace.toUpperCase() + '_';
+        for (const [key, value] of Object.entries(config)) {
+            if (key.toUpperCase().startsWith(prefix)) {
+                const namespacedKey = key.substring(prefix.length);
+                const camelCaseKey = this.toCamelCase(namespacedKey);
+                if (camelCaseKey) {
+                    prefixedConfig[camelCaseKey] = value;
+                }
+            }
+        }
+        return prefixedConfig;
+    }
+    /**
+     * Extract configuration using path patterns.
+     *
+     * @param config - Source configuration
+     * @param namespace - Target namespace
+     * @returns Path-based configuration
+     */
+    extractPathBasedConfig(config, namespace) {
+        const pathConfig = {};
+        const namespacePath = `/${namespace}/`;
+        for (const [key, value] of Object.entries(config)) {
+            if (key.includes(namespacePath)) {
+                const pathIndex = key.indexOf(namespacePath);
+                const afterNamespace = key.substring(pathIndex + namespacePath.length);
+                if (afterNamespace) {
+                    const nestedKey = this.pathToNestedKey(afterNamespace);
+                    this.setNestedValue(pathConfig, nestedKey, value);
+                }
+            }
+        }
+        return pathConfig;
+    }
+    /**
+     * Extract configuration that doesn't belong to any namespace.
+     *
+     * @param config - Source configuration
+     * @param namespaces - Known namespaces
+     * @returns Remaining configuration
+     */
+    extractRemainingConfig(config, namespaces) {
+        const remaining = {};
+        const namespacePrefixes = namespaces.map(ns => ns.toUpperCase() + '_');
+        const namespacePaths = namespaces.map(ns => `/${ns}/`);
+        for (const [key, value] of Object.entries(config)) {
+            const upperKey = key.toUpperCase();
+            // Skip if key belongs to a known namespace
+            const belongsToNamespace = namespaces.includes(key) ||
+                namespacePrefixes.some(prefix => upperKey.startsWith(prefix)) ||
+                namespacePaths.some(path => key.includes(path));
+            if (!belongsToNamespace) {
+                remaining[key] = value;
+            }
+        }
+        return remaining;
+    }
+    /**
+     * Add metadata to a factory for introspection.
+     *
+     * @param factory - Configuration factory
+     * @param namespace - Namespace name
+     * @param config - Configuration data
+     * @param sources - Configuration sources
+     */
+    addFactoryMetadata(factory, namespace, config, sources) {
+        factory.__namespace = namespace;
+        factory.__isAwsNamespaceFactory = true;
+        factory.__configKeys = Object.keys(config);
+        factory.__sources = sources?.map(s => s.name) || [];
+        factory.__createdAt = new Date().toISOString();
+    }
+    /**
+     * Transform configuration values (type conversion, etc.).
+     *
+     * @param config - Configuration to transform
+     */
+    transformConfigValues(config) {
+        for (const [key, value] of Object.entries(config)) {
+            if (typeof value === 'string') {
+                config[key] = this.convertStringValue(value);
+            }
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                this.transformConfigValues(value);
+            }
+        }
+    }
+    /**
+     * Convert string values to appropriate types.
+     *
+     * @param value - String value to convert
+     * @returns Converted value
+     */
+    convertStringValue(value) {
+        // Boolean conversion
+        if (value.toLowerCase() === 'true')
+            return true;
+        if (value.toLowerCase() === 'false')
+            return false;
+        // Number conversion
+        if (/^\d+$/.test(value)) {
+            const num = parseInt(value, 10);
+            return isNaN(num) ? value : num;
+        }
+        if (/^\d*\.\d+$/.test(value)) {
+            const num = parseFloat(value);
+            return isNaN(num) ? value : num;
+        }
+        // JSON conversion
+        if ((value.startsWith('{') && value.endsWith('}')) ||
+            (value.startsWith('[') && value.endsWith(']'))) {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        return value;
+    }
+    /**
+     * Validate processed configuration.
+     *
+     * @param config - Configuration to validate
+     * @param namespace - Namespace name
+     */
+    validateProcessedConfig(config, namespace) {
+        if (!config || typeof config !== 'object') {
+            throw new Error(`Invalid processed configuration for namespace: ${namespace}`);
+        }
+        // Additional validation can be added here
+    }
+    /**
+     * Convert snake_case or kebab-case to camelCase.
+     *
+     * @param str - String to convert
+     * @returns camelCase string
+     */
+    toCamelCase(str) {
+        return str
+            .toLowerCase()
+            .replace(/[_-](.)/g, (_, char) => char.toUpperCase());
+    }
+    /**
+     * Convert path segments to nested key structure.
+     *
+     * @param path - Path string
+     * @returns Nested key structure
+     */
+    pathToNestedKey(path) {
+        return path
+            .split('/')
+            .map(segment => this.toCamelCase(segment))
+            .join('.');
+    }
+    /**
+     * Set a nested value in an object using dot notation.
+     *
+     * @param obj - Target object
+     * @param path - Dot notation path
+     * @param value - Value to set
+     */
+    setNestedValue(obj, path, value) {
+        const keys = path.split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const key = keys[i];
+            if (key && (!(key in current) || typeof current[key] !== 'object')) {
+                current[key] = {};
+            }
+            if (key) {
+                current = current[key];
+            }
+        }
+        const lastKey = keys[keys.length - 1];
+        if (lastKey) {
+            current[lastKey] = value;
+        }
+    }
+    /**
+     * Validate namespace name.
+     *
+     * @param namespace - Namespace to validate
+     * @returns Whether namespace is valid
+     */
+    isValidNamespace(namespace) {
+        return typeof namespace === 'string' &&
+            namespace.trim() !== '' &&
+            /^[a-zA-Z][a-zA-Z0-9_]*$/.test(namespace);
+    }
+    /**
+     * Check if namespace is reserved.
+     *
+     * @param namespace - Namespace to check
+     * @returns Whether namespace is reserved
+     */
+    isReservedNamespace(namespace) {
+        const reserved = ['config', 'env', 'process', 'global', 'default', 'root'];
+        return reserved.includes(namespace.toLowerCase());
+    }
+    /**
+     * Validate namespace configuration.
+     *
+     * @param namespace - Namespace name
+     * @param config - Configuration data
+     * @returns Whether configuration is valid
+     */
+    isValidNamespaceConfig(namespace, config) {
+        return typeof namespace === 'string' &&
+            namespace.trim() !== '' &&
+            config !== null &&
+            config !== undefined &&
+            typeof config === 'object' &&
+            !Array.isArray(config) &&
+            Object.keys(config).length > 0;
+    }
+    /**
+     * Find key conflicts in configuration.
+     *
+     * @param config - Configuration to check
+     * @returns Array of conflicting keys
+     */
+    findKeyConflicts(config) {
+        const conflicts = [];
+        const keys = Object.keys(config);
+        // Check for case-insensitive duplicates
+        const lowerKeys = keys.map(k => k.toLowerCase());
+        const duplicates = lowerKeys.filter((key, index) => lowerKeys.indexOf(key) !== index);
+        conflicts.push(...duplicates);
+        return [...new Set(conflicts)];
+    }
+    /**
+     * Generate usage examples for a namespace.
+     *
+     * @param namespace - Namespace name
+     * @param config - Configuration data
+     * @returns Array of usage examples
+     */
+    generateUsageExamples(namespace, config) {
+        const examples = [];
+        const sampleKeys = Object.keys(config).slice(0, 3);
+        examples.push(`// Inject the entire ${namespace} configuration`);
+        examples.push(`@Inject(${namespace}Config.KEY) private ${namespace}: ConfigType<typeof ${namespace}Config>`);
+        examples.push('');
+        examples.push(`// Access via ConfigService`);
+        examples.push(`const ${namespace}Config = this.configService.get('${namespace}');`);
+        if (sampleKeys.length > 0) {
+            examples.push('');
+            examples.push(`// Access specific values`);
+            sampleKeys.forEach(key => {
+                examples.push(`const ${key} = this.configService.get('${namespace}.${key}');`);
+            });
+        }
+        return examples;
+    }
+};
+exports.NamespaceHandlerService = NamespaceHandlerService;
+exports.NamespaceHandlerService = NamespaceHandlerService = NamespaceHandlerService_1 = __decorate([
+    (0, common_1.Injectable)()
+], NamespaceHandlerService);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"namespace-handler.service.js","sourceRoot":"","sources":["../../../../../../src/integration/services/namespace-handler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\r\nimport { ConfigFactory, registerAs } from '@nestjs/config';\r\nimport { ConfigurationSource } from '../interfaces/configuration-source.interface';\r\n\r\n/**\r\n * Service for handling namespace-aware configuration loading and factory creation.\r\n * Provides enhanced namespace support for @nestjs/config integration.\r\n */\r\n@Injectable()\r\nexport class NamespaceHandlerService {\r\n  private readonly logger = new Logger(NamespaceHandlerService.name);\r\n\r\n  /**\r\n   * Create a registerAs factory for a specific namespace.\r\n   * This method creates a factory that can be used with @nestjs/config's registerAs pattern.\r\n   * \r\n   * @param namespace - The namespace for the configuration\r\n   * @param config - The configuration data for the namespace\r\n   * @param sources - Optional configuration sources metadata\r\n   * @returns A registerAs factory for the namespace\r\n   */\r\n  createNamespaceFactory(\r\n    namespace: string,\r\n    config: Record<string, any>,\r\n    sources?: ConfigurationSource[]\r\n  ): ConfigFactory {\r\n    this.logger.debug(`Creating namespace factory for: ${namespace}`);\r\n\r\n    // Validate namespace\r\n    if (!this.isValidNamespace(namespace)) {\r\n      throw new Error(`Invalid namespace: ${namespace}`);\r\n    }\r\n\r\n    // Create the factory function\r\n    const factory = () => {\r\n      this.logger.debug(`Namespace factory called for: ${namespace}`);\r\n      \r\n      // Process and validate configuration\r\n      const processedConfig = this.processNamespaceConfig(config, namespace);\r\n      \r\n      this.logger.debug(`Namespace factory returning ${Object.keys(processedConfig).length} keys for: ${namespace}`);\r\n      return processedConfig;\r\n    };\r\n\r\n    // Create registerAs factory\r\n    const namespacedFactory = registerAs(namespace, factory);\r\n\r\n    // Add metadata for introspection and debugging\r\n    this.addFactoryMetadata(namespacedFactory, namespace, config, sources);\r\n\r\n    return namespacedFactory;\r\n  }\r\n\r\n  /**\r\n   * Create multiple namespace factories from configuration data.\r\n   * \r\n   * @param namespacedConfig - Configuration data organized by namespace\r\n   * @param sources - Optional configuration sources metadata\r\n   * @returns Array of namespace factories\r\n   */\r\n  createMultipleNamespaceFactories(\r\n    namespacedConfig: Record<string, Record<string, any>>,\r\n    sources?: ConfigurationSource[]\r\n  ): ConfigFactory[] {\r\n    this.logger.debug(`Creating multiple namespace factories for: ${Object.keys(namespacedConfig).join(', ')}`);\r\n\r\n    const factories: ConfigFactory[] = [];\r\n\r\n    for (const [namespace, config] of Object.entries(namespacedConfig)) {\r\n      if (this.isValidNamespaceConfig(namespace, config)) {\r\n        try {\r\n          const namespaceSources = sources?.filter(s => \r\n            s.namespace === namespace || \r\n            s.data[namespace] !== undefined\r\n          );\r\n\r\n          const factory = this.createNamespaceFactory(namespace, config, namespaceSources);\r\n          factories.push(factory);\r\n          \r\n          this.logger.debug(`Created namespace factory for: ${namespace}`);\r\n        } catch (error) {\r\n          this.logger.error(`Failed to create namespace factory for ${namespace}:`, error);\r\n        }\r\n      } else {\r\n        this.logger.warn(`Skipping invalid namespace configuration: ${namespace}`);\r\n      }\r\n    }\r\n\r\n    this.logger.debug(`Created ${factories.length} namespace factories`);\r\n    return factories;\r\n  }\r\n\r\n  /**\r\n   * Extract namespace configuration from flat configuration using various strategies.\r\n   * \r\n   * @param config - Flat configuration object\r\n   * @param namespace - Target namespace\r\n   * @returns Configuration for the namespace\r\n   */\r\n  extractNamespaceConfig(config: Record<string, any>, namespace: string): Record<string, any> {\r\n    const namespaceConfig: Record<string, any> = {};\r\n\r\n    // Strategy 1: Direct namespace key (e.g., config.database)\r\n    if (config[namespace] && typeof config[namespace] === 'object') {\r\n      Object.assign(namespaceConfig, config[namespace]);\r\n    }\r\n\r\n    // Strategy 2: Prefixed keys (e.g., DATABASE_HOST -> host)\r\n    const prefixedConfig = this.extractPrefixedConfig(config, namespace);\r\n    Object.assign(namespaceConfig, prefixedConfig);\r\n\r\n    // Strategy 3: Path-based keys (e.g., /app/database/host -> host)\r\n    const pathConfig = this.extractPathBasedConfig(config, namespace);\r\n    Object.assign(namespaceConfig, pathConfig);\r\n\r\n    return namespaceConfig;\r\n  }\r\n\r\n  /**\r\n   * Organize flat configuration into namespaces based on patterns.\r\n   * \r\n   * @param config - Flat configuration object\r\n   * @param namespaces - List of target namespaces\r\n   * @returns Configuration organized by namespace\r\n   */\r\n  organizeConfigByNamespaces(\r\n    config: Record<string, any>,\r\n    namespaces: string[]\r\n  ): Record<string, Record<string, any>> {\r\n    const organized: Record<string, Record<string, any>> = {};\r\n\r\n    // Initialize all namespaces\r\n    for (const namespace of namespaces) {\r\n      organized[namespace] = {};\r\n    }\r\n\r\n    // Extract configuration for each namespace\r\n    for (const namespace of namespaces) {\r\n      organized[namespace] = this.extractNamespaceConfig(config, namespace);\r\n    }\r\n\r\n    // Handle remaining configuration that doesn't match any namespace\r\n    const remainingConfig = this.extractRemainingConfig(config, namespaces);\r\n    if (Object.keys(remainingConfig).length > 0) {\r\n      organized['default'] = remainingConfig;\r\n    }\r\n\r\n    return organized;\r\n  }\r\n\r\n  /**\r\n   * Validate namespace access patterns for @nestjs/config compatibility.\r\n   * \r\n   * @param namespace - Namespace to validate\r\n   * @param config - Configuration for the namespace\r\n   * @returns Validation result with suggestions\r\n   */\r\n  validateNamespaceAccess(\r\n    namespace: string,\r\n    config: Record<string, any>\r\n  ): {\r\n    isValid: boolean;\r\n    issues: string[];\r\n    suggestions: string[];\r\n  } {\r\n    const issues: string[] = [];\r\n    const suggestions: string[] = [];\r\n\r\n    // Check namespace name validity\r\n    if (!this.isValidNamespace(namespace)) {\r\n      issues.push(`Invalid namespace name: ${namespace}`);\r\n      suggestions.push('Use alphanumeric characters and underscores only');\r\n    }\r\n\r\n    // Check for reserved namespace names\r\n    if (this.isReservedNamespace(namespace)) {\r\n      issues.push(`Reserved namespace name: ${namespace}`);\r\n      suggestions.push('Choose a different namespace name');\r\n    }\r\n\r\n    // Check configuration structure\r\n    if (!this.isValidNamespaceConfig(namespace, config)) {\r\n      issues.push('Invalid configuration structure for namespace');\r\n      suggestions.push('Ensure configuration is a non-empty object');\r\n    }\r\n\r\n    // Check for potential key conflicts\r\n    const conflicts = this.findKeyConflicts(config);\r\n    if (conflicts.length > 0) {\r\n      issues.push(`Key conflicts found: ${conflicts.join(', ')}`);\r\n      suggestions.push('Resolve key naming conflicts');\r\n    }\r\n\r\n    return {\r\n      isValid: issues.length === 0,\r\n      issues,\r\n      suggestions\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Generate access patterns documentation for a namespace.\r\n   * \r\n   * @param namespace - Namespace name\r\n   * @param config - Configuration for the namespace\r\n   * @returns Access patterns documentation\r\n   */\r\n  generateAccessPatterns(\r\n    namespace: string,\r\n    config: Record<string, any>\r\n  ): {\r\n    namespace: string;\r\n    patterns: {\r\n      injection: string;\r\n      service: string;\r\n      direct: string;\r\n    };\r\n    examples: string[];\r\n  } {\r\n    const patterns = {\r\n      injection: `@Inject(${namespace}Config.KEY)`,\r\n      service: `this.configService.get('${namespace}')`,\r\n      direct: `this.configService.get('${namespace}.key')`\r\n    };\r\n\r\n    const examples = this.generateUsageExamples(namespace, config);\r\n\r\n    return {\r\n      namespace,\r\n      patterns,\r\n      examples\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Process namespace configuration with validation and transformation.\r\n   * \r\n   * @param config - Raw configuration for the namespace\r\n   * @param namespace - Namespace name\r\n   * @returns Processed configuration\r\n   */\r\n  private processNamespaceConfig(\r\n    config: Record<string, any>,\r\n    namespace: string\r\n  ): Record<string, any> {\r\n    // Deep clone to avoid mutations\r\n    const processed = JSON.parse(JSON.stringify(config));\r\n\r\n    // Apply transformations\r\n    this.transformConfigValues(processed);\r\n\r\n    // Validate processed configuration\r\n    this.validateProcessedConfig(processed, namespace);\r\n\r\n    return processed;\r\n  }\r\n\r\n  /**\r\n   * Extract configuration using prefix patterns.\r\n   * \r\n   * @param config - Source configuration\r\n   * @param namespace - Target namespace\r\n   * @returns Prefixed configuration\r\n   */\r\n  private extractPrefixedConfig(\r\n    config: Record<string, any>,\r\n    namespace: string\r\n  ): Record<string, any> {\r\n    const prefixedConfig: Record<string, any> = {};\r\n    const prefix = namespace.toUpperCase() + '_';\r\n\r\n    for (const [key, value] of Object.entries(config)) {\r\n      if (key.toUpperCase().startsWith(prefix)) {\r\n        const namespacedKey = key.substring(prefix.length);\r\n        const camelCaseKey = this.toCamelCase(namespacedKey);\r\n        \r\n        if (camelCaseKey) {\r\n          prefixedConfig[camelCaseKey] = value;\r\n        }\r\n      }\r\n    }\r\n\r\n    return prefixedConfig;\r\n  }\r\n\r\n  /**\r\n   * Extract configuration using path patterns.\r\n   * \r\n   * @param config - Source configuration\r\n   * @param namespace - Target namespace\r\n   * @returns Path-based configuration\r\n   */\r\n  private extractPathBasedConfig(\r\n    config: Record<string, any>,\r\n    namespace: string\r\n  ): Record<string, any> {\r\n    const pathConfig: Record<string, any> = {};\r\n    const namespacePath = `/${namespace}/`;\r\n\r\n    for (const [key, value] of Object.entries(config)) {\r\n      if (key.includes(namespacePath)) {\r\n        const pathIndex = key.indexOf(namespacePath);\r\n        const afterNamespace = key.substring(pathIndex + namespacePath.length);\r\n        \r\n        if (afterNamespace) {\r\n          const nestedKey = this.pathToNestedKey(afterNamespace);\r\n          this.setNestedValue(pathConfig, nestedKey, value);\r\n        }\r\n      }\r\n    }\r\n\r\n    return pathConfig;\r\n  }\r\n\r\n  /**\r\n   * Extract configuration that doesn't belong to any namespace.\r\n   * \r\n   * @param config - Source configuration\r\n   * @param namespaces - Known namespaces\r\n   * @returns Remaining configuration\r\n   */\r\n  private extractRemainingConfig(\r\n    config: Record<string, any>,\r\n    namespaces: string[]\r\n  ): Record<string, any> {\r\n    const remaining: Record<string, any> = {};\r\n    const namespacePrefixes = namespaces.map(ns => ns.toUpperCase() + '_');\r\n    const namespacePaths = namespaces.map(ns => `/${ns}/`);\r\n\r\n    for (const [key, value] of Object.entries(config)) {\r\n      const upperKey = key.toUpperCase();\r\n      \r\n      // Skip if key belongs to a known namespace\r\n      const belongsToNamespace = \r\n        namespaces.includes(key) ||\r\n        namespacePrefixes.some(prefix => upperKey.startsWith(prefix)) ||\r\n        namespacePaths.some(path => key.includes(path));\r\n\r\n      if (!belongsToNamespace) {\r\n        remaining[key] = value;\r\n      }\r\n    }\r\n\r\n    return remaining;\r\n  }\r\n\r\n  /**\r\n   * Add metadata to a factory for introspection.\r\n   * \r\n   * @param factory - Configuration factory\r\n   * @param namespace - Namespace name\r\n   * @param config - Configuration data\r\n   * @param sources - Configuration sources\r\n   */\r\n  private addFactoryMetadata(\r\n    factory: ConfigFactory,\r\n    namespace: string,\r\n    config: Record<string, any>,\r\n    sources?: ConfigurationSource[]\r\n  ): void {\r\n    (factory as any).__namespace = namespace;\r\n    (factory as any).__isAwsNamespaceFactory = true;\r\n    (factory as any).__configKeys = Object.keys(config);\r\n    (factory as any).__sources = sources?.map(s => s.name) || [];\r\n    (factory as any).__createdAt = new Date().toISOString();\r\n  }\r\n\r\n  /**\r\n   * Transform configuration values (type conversion, etc.).\r\n   * \r\n   * @param config - Configuration to transform\r\n   */\r\n  private transformConfigValues(config: Record<string, any>): void {\r\n    for (const [key, value] of Object.entries(config)) {\r\n      if (typeof value === 'string') {\r\n        config[key] = this.convertStringValue(value);\r\n      } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\r\n        this.transformConfigValues(value);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Convert string values to appropriate types.\r\n   * \r\n   * @param value - String value to convert\r\n   * @returns Converted value\r\n   */\r\n  private convertStringValue(value: string): any {\r\n    // Boolean conversion\r\n    if (value.toLowerCase() === 'true') return true;\r\n    if (value.toLowerCase() === 'false') return false;\r\n\r\n    // Number conversion\r\n    if (/^\\d+$/.test(value)) {\r\n      const num = parseInt(value, 10);\r\n      return isNaN(num) ? value : num;\r\n    }\r\n\r\n    if (/^\\d*\\.\\d+$/.test(value)) {\r\n      const num = parseFloat(value);\r\n      return isNaN(num) ? value : num;\r\n    }\r\n\r\n    // JSON conversion\r\n    if ((value.startsWith('{') && value.endsWith('}')) || \r\n        (value.startsWith('[') && value.endsWith(']'))) {\r\n      try {\r\n        return JSON.parse(value);\r\n      } catch {\r\n        return value;\r\n      }\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * Validate processed configuration.\r\n   * \r\n   * @param config - Configuration to validate\r\n   * @param namespace - Namespace name\r\n   */\r\n  private validateProcessedConfig(config: Record<string, any>, namespace: string): void {\r\n    if (!config || typeof config !== 'object') {\r\n      throw new Error(`Invalid processed configuration for namespace: ${namespace}`);\r\n    }\r\n\r\n    // Additional validation can be added here\r\n  }\r\n\r\n  /**\r\n   * Convert snake_case or kebab-case to camelCase.\r\n   * \r\n   * @param str - String to convert\r\n   * @returns camelCase string\r\n   */\r\n  private toCamelCase(str: string): string {\r\n    return str\r\n      .toLowerCase()\r\n      .replace(/[_-](.)/g, (_, char) => char.toUpperCase());\r\n  }\r\n\r\n  /**\r\n   * Convert path segments to nested key structure.\r\n   * \r\n   * @param path - Path string\r\n   * @returns Nested key structure\r\n   */\r\n  private pathToNestedKey(path: string): string {\r\n    return path\r\n      .split('/')\r\n      .map(segment => this.toCamelCase(segment))\r\n      .join('.');\r\n  }\r\n\r\n  /**\r\n   * Set a nested value in an object using dot notation.\r\n   * \r\n   * @param obj - Target object\r\n   * @param path - Dot notation path\r\n   * @param value - Value to set\r\n   */\r\n  private setNestedValue(obj: Record<string, any>, path: string, value: any): void {\r\n    const keys = path.split('.');\r\n    let current = obj;\r\n\r\n    for (let i = 0; i < keys.length - 1; i++) {\r\n      const key = keys[i];\r\n      if (key && (!(key in current) || typeof current[key] !== 'object')) {\r\n        current[key] = {};\r\n      }\r\n      if (key) {\r\n        current = current[key];\r\n      }\r\n    }\r\n\r\n    const lastKey = keys[keys.length - 1];\r\n    if (lastKey) {\r\n      current[lastKey] = value;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate namespace name.\r\n   * \r\n   * @param namespace - Namespace to validate\r\n   * @returns Whether namespace is valid\r\n   */\r\n  private isValidNamespace(namespace: string): boolean {\r\n    return typeof namespace === 'string' &&\r\n           namespace.trim() !== '' &&\r\n           /^[a-zA-Z][a-zA-Z0-9_]*$/.test(namespace);\r\n  }\r\n\r\n  /**\r\n   * Check if namespace is reserved.\r\n   * \r\n   * @param namespace - Namespace to check\r\n   * @returns Whether namespace is reserved\r\n   */\r\n  private isReservedNamespace(namespace: string): boolean {\r\n    const reserved = ['config', 'env', 'process', 'global', 'default', 'root'];\r\n    return reserved.includes(namespace.toLowerCase());\r\n  }\r\n\r\n  /**\r\n   * Validate namespace configuration.\r\n   * \r\n   * @param namespace - Namespace name\r\n   * @param config - Configuration data\r\n   * @returns Whether configuration is valid\r\n   */\r\n  private isValidNamespaceConfig(namespace: string, config: any): boolean {\r\n    return typeof namespace === 'string' &&\r\n           namespace.trim() !== '' &&\r\n           config !== null &&\r\n           config !== undefined &&\r\n           typeof config === 'object' &&\r\n           !Array.isArray(config) &&\r\n           Object.keys(config).length > 0;\r\n  }\r\n\r\n  /**\r\n   * Find key conflicts in configuration.\r\n   * \r\n   * @param config - Configuration to check\r\n   * @returns Array of conflicting keys\r\n   */\r\n  private findKeyConflicts(config: Record<string, any>): string[] {\r\n    const conflicts: string[] = [];\r\n    const keys = Object.keys(config);\r\n    \r\n    // Check for case-insensitive duplicates\r\n    const lowerKeys = keys.map(k => k.toLowerCase());\r\n    const duplicates = lowerKeys.filter((key, index) => lowerKeys.indexOf(key) !== index);\r\n    \r\n    conflicts.push(...duplicates);\r\n    \r\n    return [...new Set(conflicts)];\r\n  }\r\n\r\n  /**\r\n   * Generate usage examples for a namespace.\r\n   * \r\n   * @param namespace - Namespace name\r\n   * @param config - Configuration data\r\n   * @returns Array of usage examples\r\n   */\r\n  private generateUsageExamples(namespace: string, config: Record<string, any>): string[] {\r\n    const examples: string[] = [];\r\n    const sampleKeys = Object.keys(config).slice(0, 3);\r\n\r\n    examples.push(`// Inject the entire ${namespace} configuration`);\r\n    examples.push(`@Inject(${namespace}Config.KEY) private ${namespace}: ConfigType<typeof ${namespace}Config>`);\r\n    examples.push('');\r\n    examples.push(`// Access via ConfigService`);\r\n    examples.push(`const ${namespace}Config = this.configService.get('${namespace}');`);\r\n    \r\n    if (sampleKeys.length > 0) {\r\n      examples.push('');\r\n      examples.push(`// Access specific values`);\r\n      sampleKeys.forEach(key => {\r\n        examples.push(`const ${key} = this.configService.get('${namespace}.${key}');`);\r\n      });\r\n    }\r\n\r\n    return examples;\r\n  }\r\n}"]}