@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

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

@@ -0,0 +1,142 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ConfigServiceImpl_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigServiceImpl = void 0;
+const common_1 = require("@nestjs/common");
+const config_aws_1 = require("@dyanet/config-aws");
+const config_service_interface_1 = require("../interfaces/config-service.interface");
+/**
+ * NestJS Injectable wrapper around ConfigManager from @dyanet/config-aws.
+ * Provides type-safe configuration access with NestJS dependency injection support.
+ *
+ * This is a thin adapter layer that delegates all configuration loading and
+ * management to the framework-agnostic ConfigManager from config-aws.
+ *
+ * @example
+ * ```typescript
+ * import { ConfigServiceImpl } from '@dyanet/nestjs-config-aws';
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *   DATABASE_URL: z.string(),
+ *   PORT: z.coerce.number().default(3000),
+ * });
+ *
+ * const configService = new ConfigServiceImpl({
+ *   loaders: [new EnvironmentLoader()],
+ *   schema,
+ * });
+ *
+ * await configService.initialize();
+ * const dbUrl = configService.get('DATABASE_URL');
+ * ```
+ */
+let ConfigServiceImpl = ConfigServiceImpl_1 = class ConfigServiceImpl extends config_service_interface_1.ConfigService {
+    logger = new common_1.Logger(ConfigServiceImpl_1.name);
+    configManager;
+    enableNestLogging;
+    constructor(options = {}) {
+        super();
+        this.enableNestLogging = options.enableNestLogging ?? true;
+        // Create ConfigManager from config-aws with provided options
+        this.configManager = new config_aws_1.ConfigManager({
+            loaders: options.loaders,
+            schema: options.schema,
+            precedence: options.precedence,
+            validateOnLoad: options.validateOnLoad,
+            enableLogging: options.enableLogging,
+            logger: options.logger,
+            verbose: options.verbose,
+        });
+    }
+    /**
+     * Initialize the configuration service by loading configuration from all sources.
+     * This method should be called during application startup.
+     *
+     * @throws ConfigurationError if loading or validation fails
+     */
+    async initialize() {
+        if (this.configManager.isLoaded()) {
+            return;
+        }
+        try {
+            if (this.enableNestLogging) {
+                this.logger.log('Initializing configuration service...');
+            }
+            await this.configManager.load();
+            if (this.enableNestLogging) {
+                this.logger.log('Configuration service initialized successfully');
+            }
+        }
+        catch (error) {
+            const errorMessage = `Failed to initialize configuration service: ${error instanceof Error ? error.message : String(error)}`;
+            this.logger.error(errorMessage);
+            throw error;
+        }
+    }
+    /**
+     * Get a configuration value by key with type safety.
+     *
+     * @param key - The configuration key to retrieve
+     * @returns The configuration value with proper typing
+     * @throws ConfigurationError if configuration is not initialized
+     */
+    get(key) {
+        if (!this.configManager.isLoaded()) {
+            throw new config_aws_1.ConfigurationError('Configuration service not initialized. Call initialize() first.');
+        }
+        return this.configManager.get(key);
+    }
+    /**
+     * Check if the configuration service has been initialized.
+     *
+     * @returns True if the service is ready to serve configuration values
+     */
+    isInitialized() {
+        return this.configManager.isLoaded();
+    }
+    /**
+     * Get all configuration values.
+     *
+     * @returns The complete configuration object
+     * @throws ConfigurationError if configuration is not initialized
+     */
+    getAll() {
+        if (!this.configManager.isLoaded()) {
+            throw new config_aws_1.ConfigurationError('Configuration service not initialized. Call initialize() first.');
+        }
+        return this.configManager.getAll();
+    }
+    /**
+     * Get the current application environment.
+     *
+     * @returns The APP_ENV value or 'development' as default
+     */
+    getAppEnv() {
+        return this.configManager.getAppEnv();
+    }
+    /**
+     * Get the underlying ConfigManager instance.
+     * Useful for advanced use cases that need direct access to ConfigManager features.
+     *
+     * @returns The ConfigManager instance from @dyanet/config-aws
+     */
+    getConfigManager() {
+        return this.configManager;
+    }
+};
+exports.ConfigServiceImpl = ConfigServiceImpl;
+exports.ConfigServiceImpl = ConfigServiceImpl = ConfigServiceImpl_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], ConfigServiceImpl);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.service.js","sourceRoot":"","sources":["../../../../../src/services/config.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,2CAAoD;AACpD,mDAAuE;AAGvE,qFAAuE;AAcvE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEI,IAAM,iBAAiB,yBAAvB,MAAM,iBAA+C,SAAQ,wCAAgB;IACjE,MAAM,GAAG,IAAI,eAAM,CAAC,mBAAiB,CAAC,IAAI,CAAC,CAAC;IAC5C,aAAa,CAAmB;IAChC,iBAAiB,CAAU;IAE5C,YAAY,UAAmC,EAAE;QAC/C,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,IAAI,CAAC;QAE3D,6DAA6D;QAC7D,IAAI,CAAC,aAAa,GAAG,IAAI,0BAAa,CAAI;YACxC,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,cAAc,EAAE,OAAO,CAAC,cAAc;YACtC,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO;SACzB,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YAClC,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;YAC3D,CAAC;YAED,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YAEhC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;YACpE,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,+CAA+C,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7H,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAChC,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAoB,GAAM;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,+BAAkB,CAC1B,iEAAiE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,MAAM;QACJ,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,+BAAkB,CAC1B,iEAAiE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;CACF,CAAA;AA5GY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,mBAAU,GAAE;;GACA,iBAAiB,CA4G7B","sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\r\nimport { ConfigManager, ConfigurationError } from '@dyanet/config-aws';\r\nimport type { ConfigManagerOptions } from '@dyanet/config-aws';\r\n\r\nimport { ConfigService } from '../interfaces/config-service.interface';\r\n\r\n/**\r\n * Configuration options for NestJS ConfigService wrapper.\r\n * Extends ConfigManagerOptions from @dyanet/config-aws.\r\n */\r\nexport interface ConfigServiceOptions<T = Record<string, unknown>> extends ConfigManagerOptions<T> {\r\n  /**\r\n   * Whether to enable NestJS logging\r\n   * @default true\r\n   */\r\n  enableNestLogging?: boolean;\r\n}\r\n\r\n/**\r\n * NestJS Injectable wrapper around ConfigManager from @dyanet/config-aws.\r\n * Provides type-safe configuration access with NestJS dependency injection support.\r\n * \r\n * This is a thin adapter layer that delegates all configuration loading and\r\n * management to the framework-agnostic ConfigManager from config-aws.\r\n * \r\n * @example\r\n * ```typescript\r\n * import { ConfigServiceImpl } from '@dyanet/nestjs-config-aws';\r\n * import { z } from 'zod';\r\n * \r\n * const schema = z.object({\r\n *   DATABASE_URL: z.string(),\r\n *   PORT: z.coerce.number().default(3000),\r\n * });\r\n * \r\n * const configService = new ConfigServiceImpl({\r\n *   loaders: [new EnvironmentLoader()],\r\n *   schema,\r\n * });\r\n * \r\n * await configService.initialize();\r\n * const dbUrl = configService.get('DATABASE_URL');\r\n * ```\r\n */\r\n@Injectable()\r\nexport class ConfigServiceImpl<T = Record<string, unknown>> extends ConfigService<T> {\r\n  private readonly logger = new Logger(ConfigServiceImpl.name);\r\n  private readonly configManager: ConfigManager<T>;\r\n  private readonly enableNestLogging: boolean;\r\n\r\n  constructor(options: ConfigServiceOptions<T> = {}) {\r\n    super();\r\n    \r\n    this.enableNestLogging = options.enableNestLogging ?? true;\r\n    \r\n    // Create ConfigManager from config-aws with provided options\r\n    this.configManager = new ConfigManager<T>({\r\n      loaders: options.loaders,\r\n      schema: options.schema,\r\n      precedence: options.precedence,\r\n      validateOnLoad: options.validateOnLoad,\r\n      enableLogging: options.enableLogging,\r\n      logger: options.logger,\r\n      verbose: options.verbose,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Initialize the configuration service by loading configuration from all sources.\r\n   * This method should be called during application startup.\r\n   * \r\n   * @throws ConfigurationError if loading or validation fails\r\n   */\r\n  async initialize(): Promise<void> {\r\n    if (this.configManager.isLoaded()) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      if (this.enableNestLogging) {\r\n        this.logger.log('Initializing configuration service...');\r\n      }\r\n\r\n      await this.configManager.load();\r\n\r\n      if (this.enableNestLogging) {\r\n        this.logger.log('Configuration service initialized successfully');\r\n      }\r\n    } catch (error) {\r\n      const errorMessage = `Failed to initialize configuration service: ${error instanceof Error ? error.message : String(error)}`;\r\n      this.logger.error(errorMessage);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get a configuration value by key with type safety.\r\n   * \r\n   * @param key - The configuration key to retrieve\r\n   * @returns The configuration value with proper typing\r\n   * @throws ConfigurationError if configuration is not initialized\r\n   */\r\n  get<K extends keyof T>(key: K): T[K] {\r\n    if (!this.configManager.isLoaded()) {\r\n      throw new ConfigurationError(\r\n        'Configuration service not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n    return this.configManager.get(key);\r\n  }\r\n\r\n  /**\r\n   * Check if the configuration service has been initialized.\r\n   * \r\n   * @returns True if the service is ready to serve configuration values\r\n   */\r\n  isInitialized(): boolean {\r\n    return this.configManager.isLoaded();\r\n  }\r\n\r\n  /**\r\n   * Get all configuration values.\r\n   * \r\n   * @returns The complete configuration object\r\n   * @throws ConfigurationError if configuration is not initialized\r\n   */\r\n  getAll(): T {\r\n    if (!this.configManager.isLoaded()) {\r\n      throw new ConfigurationError(\r\n        'Configuration service not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n    return this.configManager.getAll();\r\n  }\r\n\r\n  /**\r\n   * Get the current application environment.\r\n   * \r\n   * @returns The APP_ENV value or 'development' as default\r\n   */\r\n  getAppEnv(): string {\r\n    return this.configManager.getAppEnv();\r\n  }\r\n\r\n  /**\r\n   * Get the underlying ConfigManager instance.\r\n   * Useful for advanced use cases that need direct access to ConfigManager features.\r\n   * \r\n   * @returns The ConfigManager instance from @dyanet/config-aws\r\n   */\r\n  getConfigManager(): ConfigManager<T> {\r\n    return this.configManager;\r\n  }\r\n}\r\n"]}

package/dist/esm/config-aws/src/config-manager.js

@@ -0,0 +1,362 @@
+import { ConfigurationError, ConfigurationLoadError, ValidationError } from './errors';
+/**
+ * Default console logger implementation
+ */
+const defaultLogger = {
+    log: (message) => console.log(message),
+    error: (message) => console.error(message),
+    warn: (message) => console.warn(message),
+    debug: (message) => console.debug(message),
+};
+/**
+ * Default sensitive keys that should always be masked
+ */
+const DEFAULT_SENSITIVE_KEYS = ['password', 'secret', 'key', 'token', 'credential', 'api_key', 'apikey'];
+/**
+ * Default verbose options
+ */
+const DEFAULT_VERBOSE_OPTIONS = {
+    logKeys: true,
+    logValues: false,
+    logOverrides: true,
+    logTiming: true,
+    maskValues: true,
+    sensitiveKeys: DEFAULT_SENSITIVE_KEYS,
+};
+/**
+ * Predefined precedence orders for common strategies
+ * Higher index = higher priority (later loaders override earlier ones)
+ */
+const PRECEDENCE_ORDERS = {
+    // AWS wins: env -> envFile -> s3 -> secretsManager -> ssm
+    'aws-first': [
+        'EnvironmentLoader',
+        'EnvFileLoader',
+        'S3Loader',
+        'SecretsManagerLoader',
+        'SSMParameterStoreLoader',
+    ],
+    // Local wins: ssm -> secretsManager -> s3 -> envFile -> env
+    'local-first': [
+        'SSMParameterStoreLoader',
+        'SecretsManagerLoader',
+        'S3Loader',
+        'EnvFileLoader',
+        'EnvironmentLoader',
+    ],
+};
+/**
+ * ConfigManager orchestrates loading configuration from multiple sources
+ * with configurable precedence and validation.
+ *
+ * @example
+ * ```typescript
+ * import { ConfigManager, EnvironmentLoader, SecretsManagerLoader } from '@dyanet/config-aws';
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *   DATABASE_URL: z.string(),
+ *   API_KEY: z.string(),
+ *   PORT: z.coerce.number().default(3000),
+ * });
+ *
+ * const manager = new ConfigManager({
+ *   loaders: [
+ *     new EnvironmentLoader({ prefix: 'APP_' }),
+ *     new SecretsManagerLoader({ secretName: '/my-app/config' }),
+ *   ],
+ *   schema,
+ *   precedence: 'aws-first',
+ *   verbose: true,
+ * });
+ *
+ * await manager.load();
+ * const dbUrl = manager.get('DATABASE_URL');
+ * ```
+ */
+export class ConfigManager {
+    /** @internal */
+    _options;
+    /** @internal */
+    _logger;
+    /** @internal */
+    _verboseOptions;
+    config = null;
+    loadResult = null;
+    loaded = false;
+    constructor(options = {}) {
+        this._options = {
+            loaders: options.loaders ?? [],
+            schema: options.schema,
+            precedence: options.precedence ?? 'aws-first',
+            validateOnLoad: options.validateOnLoad ?? true,
+            enableLogging: options.enableLogging ?? false,
+            logger: options.logger,
+            verbose: options.verbose,
+        };
+        this._logger = options.logger ?? defaultLogger;
+        this._verboseOptions = this.resolveVerboseOptions(options.verbose);
+    }
+    /**
+     * Resolve verbose options from boolean or object
+     */
+    resolveVerboseOptions(verbose) {
+        if (verbose === undefined || verbose === false) {
+            return null;
+        }
+        if (verbose === true) {
+            return { ...DEFAULT_VERBOSE_OPTIONS };
+        }
+        return {
+            logKeys: verbose.logKeys ?? DEFAULT_VERBOSE_OPTIONS.logKeys,
+            logValues: verbose.logValues ?? DEFAULT_VERBOSE_OPTIONS.logValues,
+            logOverrides: verbose.logOverrides ?? DEFAULT_VERBOSE_OPTIONS.logOverrides,
+            logTiming: verbose.logTiming ?? DEFAULT_VERBOSE_OPTIONS.logTiming,
+            maskValues: verbose.maskValues ?? DEFAULT_VERBOSE_OPTIONS.maskValues,
+            sensitiveKeys: verbose.sensitiveKeys ?? DEFAULT_VERBOSE_OPTIONS.sensitiveKeys,
+        };
+    }
+    /**
+     * Log a message if logging is enabled
+     */
+    log(message) {
+        if (this._options.enableLogging || this._verboseOptions) {
+            this._logger.log(`[config-aws] ${message}`);
+        }
+    }
+    /**
+     * Mask a value for logging
+     */
+    maskValue(key, value) {
+        if (!this._verboseOptions?.logValues) {
+            return '';
+        }
+        const strValue = String(value);
+        const lowerKey = key.toLowerCase();
+        // Check if key contains any sensitive patterns
+        const isSensitive = this._verboseOptions.sensitiveKeys.some((pattern) => lowerKey.includes(pattern.toLowerCase()));
+        if (this._verboseOptions.maskValues || isSensitive) {
+            if (strValue.length <= 4) {
+                return '****';
+            }
+            return `${strValue.slice(0, 2)}**...${strValue.slice(-2)}`;
+        }
+        return strValue;
+    }
+    /**
+     * Get the loading order for loaders based on precedence strategy.
+     * Returns loaders sorted by priority (lower priority first, so higher priority loads last and wins).
+     */
+    getLoadOrder() {
+        const { loaders, precedence } = this._options;
+        if (!loaders || loaders.length === 0) {
+            return [];
+        }
+        // If precedence is a custom array, use it
+        if (Array.isArray(precedence)) {
+            return this.sortByCustomPrecedence(loaders, precedence);
+        }
+        // Use predefined precedence order
+        const order = PRECEDENCE_ORDERS[precedence];
+        return this.sortByPredefinedOrder(loaders, order);
+    }
+    /**
+     * Sort loaders by custom precedence configuration
+     */
+    sortByCustomPrecedence(loaders, precedence) {
+        const priorityMap = new Map();
+        for (const p of precedence) {
+            priorityMap.set(p.loader, p.priority);
+        }
+        // Sort by priority (lower first, so higher priority loads last and wins)
+        return [...loaders].sort((a, b) => {
+            const priorityA = priorityMap.get(a.getName()) ?? 0;
+            const priorityB = priorityMap.get(b.getName()) ?? 0;
+            return priorityA - priorityB;
+        });
+    }
+    /**
+     * Sort loaders by predefined order
+     */
+    sortByPredefinedOrder(loaders, order) {
+        const orderMap = new Map();
+        order.forEach((name, index) => orderMap.set(name, index));
+        // Sort by order index (lower first, so higher index loads last and wins)
+        return [...loaders].sort((a, b) => {
+            const indexA = orderMap.get(a.getName()) ?? -1;
+            const indexB = orderMap.get(b.getName()) ?? -1;
+            return indexA - indexB;
+        });
+    }
+    /**
+     * Load configuration from all configured loaders.
+     * Loaders are executed in precedence order, with later loaders overriding earlier ones.
+     */
+    async load() {
+        const startTime = Date.now();
+        const sources = [];
+        let mergedConfig = {};
+        const keyOrigins = new Map(); // Track which loader set each key
+        this.log('Loading configuration...');
+        const orderedLoaders = this.getLoadOrder();
+        for (const loader of orderedLoaders) {
+            const loaderName = loader.getName();
+            const loaderStartTime = Date.now();
+            try {
+                // Check if loader is available
+                const isAvailable = await loader.isAvailable();
+                if (!isAvailable) {
+                    if (this._verboseOptions?.logTiming) {
+                        this.log(`${loaderName}: skipped (not available)`);
+                    }
+                    continue;
+                }
+                // Load configuration from this loader
+                const loaderConfig = await loader.load();
+                const keysLoaded = Object.keys(loaderConfig);
+                const duration = Date.now() - loaderStartTime;
+                // Track source info
+                sources.push({
+                    loader: loaderName,
+                    keysLoaded,
+                    duration,
+                });
+                // Log timing and keys
+                if (this._verboseOptions?.logTiming) {
+                    this.log(`${loaderName}: loaded ${keysLoaded.length} keys in ${duration}ms`);
+                }
+                // Log individual keys and track overrides
+                for (const key of keysLoaded) {
+                    const previousLoader = keyOrigins.get(key);
+                    const isOverride = previousLoader !== undefined;
+                    if (this._verboseOptions?.logKeys) {
+                        let logLine = `  - ${key}`;
+                        if (this._verboseOptions.logValues) {
+                            logLine += ` = "${this.maskValue(key, loaderConfig[key])}"`;
+                        }
+                        if (isOverride && this._verboseOptions.logOverrides) {
+                            logLine += ` (overrides ${previousLoader})`;
+                        }
+                        this.log(logLine);
+                    }
+                    keyOrigins.set(key, loaderName);
+                }
+                // Merge configuration (later loaders override earlier ones)
+                mergedConfig = { ...mergedConfig, ...loaderConfig };
+            }
+            catch (error) {
+                throw new ConfigurationLoadError(`Failed to load configuration from ${loaderName}: ${error instanceof Error ? error.message : String(error)}`, loaderName, error instanceof Error ? error : undefined);
+            }
+        }
+        // Count overrides
+        const totalKeys = Object.keys(mergedConfig).length;
+        const totalDuration = Date.now() - startTime;
+        const overrideCount = sources.reduce((acc, s) => acc + s.keysLoaded.length, 0) - totalKeys;
+        if (this._verboseOptions?.logTiming) {
+            this.log(`Configuration loaded: ${totalKeys} total keys, ${overrideCount} overrides, ${totalDuration}ms total`);
+        }
+        // Validate if schema is provided and validation is enabled
+        if (this._options.schema && this._options.validateOnLoad) {
+            const result = this._options.schema.safeParse(mergedConfig);
+            if (!result.success) {
+                const zodError = result.error;
+                throw new ValidationError(`Configuration validation failed: ${zodError.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`, zodError.errors, undefined);
+            }
+            this.config = result.data;
+        }
+        else {
+            this.config = mergedConfig;
+        }
+        this.loadResult = {
+            config: this.config,
+            sources,
+            loadedAt: new Date(),
+        };
+        this.loaded = true;
+    }
+    /**
+     * Get a specific configuration value by key.
+     * @param key The configuration key
+     * @returns The configuration value
+     * @throws ConfigurationError if configuration is not loaded
+     */
+    get(key) {
+        if (!this.loaded || this.config === null) {
+            throw new ConfigurationError('Configuration not loaded. Call load() first.');
+        }
+        // Non-null assertion is safe here because we've checked this.config !== null above
+        return this.config[key];
+    }
+    /**
+     * Get all configuration values.
+     * @returns The complete configuration object
+     * @throws ConfigurationError if configuration is not loaded
+     */
+    getAll() {
+        if (!this.loaded || this.config === null) {
+            throw new ConfigurationError('Configuration not loaded. Call load() first.');
+        }
+        return this.config;
+    }
+    /**
+     * Check if configuration has been loaded.
+     * @returns true if configuration is loaded
+     */
+    isLoaded() {
+        return this.loaded;
+    }
+    /**
+     * Get the current application environment.
+     * @returns The APP_ENV value or 'development' as default
+     */
+    getAppEnv() {
+        return process.env['APP_ENV'] ?? 'development';
+    }
+    /**
+     * Get the load result with source information.
+     * @returns The load result or null if not loaded
+     */
+    getLoadResult() {
+        return this.loadResult;
+    }
+    /**
+     * Serialize the current configuration to JSON string.
+     * @returns JSON string representation of the configuration
+     * @throws ConfigurationError if configuration is not loaded
+     */
+    serialize() {
+        if (!this.loaded || this.config === null) {
+            throw new ConfigurationError('Configuration not loaded. Call load() first.');
+        }
+        return JSON.stringify(this.config);
+    }
+    /**
+     * Create a new ConfigManager with configuration loaded from a JSON string.
+     * This is useful for restoring configuration from a serialized state.
+     * @param json JSON string to deserialize
+     * @param options Optional ConfigManager options (schema will be used for validation)
+     * @returns A new ConfigManager instance with the deserialized configuration
+     */
+    static deserialize(json, options = {}) {
+        const parsed = JSON.parse(json);
+        // Validate if schema is provided
+        if (options.schema) {
+            const result = options.schema.safeParse(parsed);
+            if (!result.success) {
+                const zodError = result.error;
+                throw new ValidationError(`Deserialization validation failed: ${zodError.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`, zodError.errors, undefined);
+            }
+        }
+        // Create a new ConfigManager and set its internal state
+        const manager = new ConfigManager(options);
+        manager.config = parsed;
+        manager.loaded = true;
+        manager.loadResult = {
+            config: parsed,
+            sources: [{ loader: 'deserialize', keysLoaded: Object.keys(parsed), duration: 0 }],
+            loadedAt: new Date(),
+        };
+        return manager;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-manager.js","sourceRoot":"","sources":["../../../../../config-aws/src/config-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ZodError } from 'zod';\r\nimport type { ConfigLoader } from './interfaces/config-loader.interface';\r\nimport type {\r\n  ConfigManagerOptions,\r\n  ConfigLoadResult,\r\n  ConfigSourceInfo,\r\n  Logger,\r\n  LoaderPrecedence,\r\n  VerboseOptions,\r\n} from './interfaces/config-manager.interface';\r\nimport { ConfigurationError, ConfigurationLoadError, ValidationError } from './errors';\r\n\r\n/**\r\n * Default console logger implementation\r\n */\r\nconst defaultLogger: Logger = {\r\n  log: (message: string) => console.log(message),\r\n  error: (message: string) => console.error(message),\r\n  warn: (message: string) => console.warn(message),\r\n  debug: (message: string) => console.debug(message),\r\n};\r\n\r\n/**\r\n * Default sensitive keys that should always be masked\r\n */\r\nconst DEFAULT_SENSITIVE_KEYS = ['password', 'secret', 'key', 'token', 'credential', 'api_key', 'apikey'];\r\n\r\n/**\r\n * Default verbose options\r\n */\r\nconst DEFAULT_VERBOSE_OPTIONS: Required<VerboseOptions> = {\r\n  logKeys: true,\r\n  logValues: false,\r\n  logOverrides: true,\r\n  logTiming: true,\r\n  maskValues: true,\r\n  sensitiveKeys: DEFAULT_SENSITIVE_KEYS,\r\n};\r\n\r\n/**\r\n * Predefined precedence orders for common strategies\r\n * Higher index = higher priority (later loaders override earlier ones)\r\n */\r\nconst PRECEDENCE_ORDERS: Record<'aws-first' | 'local-first', string[]> = {\r\n  // AWS wins: env -> envFile -> s3 -> secretsManager -> ssm\r\n  'aws-first': [\r\n    'EnvironmentLoader',\r\n    'EnvFileLoader',\r\n    'S3Loader',\r\n    'SecretsManagerLoader',\r\n    'SSMParameterStoreLoader',\r\n  ],\r\n  // Local wins: ssm -> secretsManager -> s3 -> envFile -> env\r\n  'local-first': [\r\n    'SSMParameterStoreLoader',\r\n    'SecretsManagerLoader',\r\n    'S3Loader',\r\n    'EnvFileLoader',\r\n    'EnvironmentLoader',\r\n  ],\r\n};\r\n\r\n\r\n/**\r\n * ConfigManager orchestrates loading configuration from multiple sources\r\n * with configurable precedence and validation.\r\n *\r\n * @example\r\n * ```typescript\r\n * import { ConfigManager, EnvironmentLoader, SecretsManagerLoader } from '@dyanet/config-aws';\r\n * import { z } from 'zod';\r\n *\r\n * const schema = z.object({\r\n *   DATABASE_URL: z.string(),\r\n *   API_KEY: z.string(),\r\n *   PORT: z.coerce.number().default(3000),\r\n * });\r\n *\r\n * const manager = new ConfigManager({\r\n *   loaders: [\r\n *     new EnvironmentLoader({ prefix: 'APP_' }),\r\n *     new SecretsManagerLoader({ secretName: '/my-app/config' }),\r\n *   ],\r\n *   schema,\r\n *   precedence: 'aws-first',\r\n *   verbose: true,\r\n * });\r\n *\r\n * await manager.load();\r\n * const dbUrl = manager.get('DATABASE_URL');\r\n * ```\r\n */\r\nexport class ConfigManager<T = Record<string, unknown>> {\r\n  /** @internal */\r\n  protected readonly _options: Required<Omit<ConfigManagerOptions<T>, 'schema' | 'logger' | 'verbose'>> & {\r\n    schema?: ConfigManagerOptions<T>['schema'];\r\n    logger?: Logger;\r\n    verbose?: VerboseOptions | boolean;\r\n  };\r\n  /** @internal */\r\n  protected readonly _logger: Logger;\r\n  /** @internal */\r\n  protected readonly _verboseOptions: Required<VerboseOptions> | null;\r\n\r\n  private config: T | null = null;\r\n  private loadResult: ConfigLoadResult<T> | null = null;\r\n  private loaded = false;\r\n\r\n  constructor(options: ConfigManagerOptions<T> = {}) {\r\n    this._options = {\r\n      loaders: options.loaders ?? [],\r\n      schema: options.schema,\r\n      precedence: options.precedence ?? 'aws-first',\r\n      validateOnLoad: options.validateOnLoad ?? true,\r\n      enableLogging: options.enableLogging ?? false,\r\n      logger: options.logger,\r\n      verbose: options.verbose,\r\n    };\r\n    this._logger = options.logger ?? defaultLogger;\r\n    this._verboseOptions = this.resolveVerboseOptions(options.verbose);\r\n  }\r\n\r\n  /**\r\n   * Resolve verbose options from boolean or object\r\n   */\r\n  private resolveVerboseOptions(verbose?: VerboseOptions | boolean): Required<VerboseOptions> | null {\r\n    if (verbose === undefined || verbose === false) {\r\n      return null;\r\n    }\r\n    if (verbose === true) {\r\n      return { ...DEFAULT_VERBOSE_OPTIONS };\r\n    }\r\n    return {\r\n      logKeys: verbose.logKeys ?? DEFAULT_VERBOSE_OPTIONS.logKeys,\r\n      logValues: verbose.logValues ?? DEFAULT_VERBOSE_OPTIONS.logValues,\r\n      logOverrides: verbose.logOverrides ?? DEFAULT_VERBOSE_OPTIONS.logOverrides,\r\n      logTiming: verbose.logTiming ?? DEFAULT_VERBOSE_OPTIONS.logTiming,\r\n      maskValues: verbose.maskValues ?? DEFAULT_VERBOSE_OPTIONS.maskValues,\r\n      sensitiveKeys: verbose.sensitiveKeys ?? DEFAULT_VERBOSE_OPTIONS.sensitiveKeys,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Log a message if logging is enabled\r\n   */\r\n  private log(message: string): void {\r\n    if (this._options.enableLogging || this._verboseOptions) {\r\n      this._logger.log(`[config-aws] ${message}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Mask a value for logging\r\n   */\r\n  private maskValue(key: string, value: unknown): string {\r\n    if (!this._verboseOptions?.logValues) {\r\n      return '';\r\n    }\r\n\r\n    const strValue = String(value);\r\n    const lowerKey = key.toLowerCase();\r\n\r\n    // Check if key contains any sensitive patterns\r\n    const isSensitive = this._verboseOptions.sensitiveKeys.some(\r\n      (pattern) => lowerKey.includes(pattern.toLowerCase())\r\n    );\r\n\r\n    if (this._verboseOptions.maskValues || isSensitive) {\r\n      if (strValue.length <= 4) {\r\n        return '****';\r\n      }\r\n      return `${strValue.slice(0, 2)}**...${strValue.slice(-2)}`;\r\n    }\r\n\r\n    return strValue;\r\n  }\r\n\r\n\r\n  /**\r\n   * Get the loading order for loaders based on precedence strategy.\r\n   * Returns loaders sorted by priority (lower priority first, so higher priority loads last and wins).\r\n   */\r\n  private getLoadOrder(): ConfigLoader[] {\r\n    const { loaders, precedence } = this._options;\r\n\r\n    if (!loaders || loaders.length === 0) {\r\n      return [];\r\n    }\r\n\r\n    // If precedence is a custom array, use it\r\n    if (Array.isArray(precedence)) {\r\n      return this.sortByCustomPrecedence(loaders, precedence);\r\n    }\r\n\r\n    // Use predefined precedence order\r\n    const order = PRECEDENCE_ORDERS[precedence];\r\n    return this.sortByPredefinedOrder(loaders, order);\r\n  }\r\n\r\n  /**\r\n   * Sort loaders by custom precedence configuration\r\n   */\r\n  private sortByCustomPrecedence(loaders: ConfigLoader[], precedence: LoaderPrecedence[]): ConfigLoader[] {\r\n    const priorityMap = new Map<string, number>();\r\n    for (const p of precedence) {\r\n      priorityMap.set(p.loader, p.priority);\r\n    }\r\n\r\n    // Sort by priority (lower first, so higher priority loads last and wins)\r\n    return [...loaders].sort((a, b) => {\r\n      const priorityA = priorityMap.get(a.getName()) ?? 0;\r\n      const priorityB = priorityMap.get(b.getName()) ?? 0;\r\n      return priorityA - priorityB;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sort loaders by predefined order\r\n   */\r\n  private sortByPredefinedOrder(loaders: ConfigLoader[], order: string[]): ConfigLoader[] {\r\n    const orderMap = new Map<string, number>();\r\n    order.forEach((name, index) => orderMap.set(name, index));\r\n\r\n    // Sort by order index (lower first, so higher index loads last and wins)\r\n    return [...loaders].sort((a, b) => {\r\n      const indexA = orderMap.get(a.getName()) ?? -1;\r\n      const indexB = orderMap.get(b.getName()) ?? -1;\r\n      return indexA - indexB;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Load configuration from all configured loaders.\r\n   * Loaders are executed in precedence order, with later loaders overriding earlier ones.\r\n   */\r\n  async load(): Promise<void> {\r\n    const startTime = Date.now();\r\n    const sources: ConfigSourceInfo[] = [];\r\n    let mergedConfig: Record<string, unknown> = {};\r\n    const keyOrigins: Map<string, string> = new Map(); // Track which loader set each key\r\n\r\n    this.log('Loading configuration...');\r\n\r\n    const orderedLoaders = this.getLoadOrder();\r\n\r\n    for (const loader of orderedLoaders) {\r\n      const loaderName = loader.getName();\r\n      const loaderStartTime = Date.now();\r\n\r\n      try {\r\n        // Check if loader is available\r\n        const isAvailable = await loader.isAvailable();\r\n        if (!isAvailable) {\r\n          if (this._verboseOptions?.logTiming) {\r\n            this.log(`${loaderName}: skipped (not available)`);\r\n          }\r\n          continue;\r\n        }\r\n\r\n        // Load configuration from this loader\r\n        const loaderConfig = await loader.load();\r\n        const keysLoaded = Object.keys(loaderConfig);\r\n        const duration = Date.now() - loaderStartTime;\r\n\r\n        // Track source info\r\n        sources.push({\r\n          loader: loaderName,\r\n          keysLoaded,\r\n          duration,\r\n        });\r\n\r\n        // Log timing and keys\r\n        if (this._verboseOptions?.logTiming) {\r\n          this.log(`${loaderName}: loaded ${keysLoaded.length} keys in ${duration}ms`);\r\n        }\r\n\r\n        // Log individual keys and track overrides\r\n        for (const key of keysLoaded) {\r\n          const previousLoader = keyOrigins.get(key);\r\n          const isOverride = previousLoader !== undefined;\r\n\r\n          if (this._verboseOptions?.logKeys) {\r\n            let logLine = `  - ${key}`;\r\n            if (this._verboseOptions.logValues) {\r\n              logLine += ` = \"${this.maskValue(key, loaderConfig[key])}\"`;\r\n            }\r\n            if (isOverride && this._verboseOptions.logOverrides) {\r\n              logLine += ` (overrides ${previousLoader})`;\r\n            }\r\n            this.log(logLine);\r\n          }\r\n\r\n          keyOrigins.set(key, loaderName);\r\n        }\r\n\r\n        // Merge configuration (later loaders override earlier ones)\r\n        mergedConfig = { ...mergedConfig, ...loaderConfig };\r\n      } catch (error) {\r\n        throw new ConfigurationLoadError(\r\n          `Failed to load configuration from ${loaderName}: ${error instanceof Error ? error.message : String(error)}`,\r\n          loaderName,\r\n          error instanceof Error ? error : undefined\r\n        );\r\n      }\r\n    }\r\n\r\n    // Count overrides\r\n    const totalKeys = Object.keys(mergedConfig).length;\r\n    const totalDuration = Date.now() - startTime;\r\n    const overrideCount = sources.reduce((acc, s) => acc + s.keysLoaded.length, 0) - totalKeys;\r\n\r\n    if (this._verboseOptions?.logTiming) {\r\n      this.log(`Configuration loaded: ${totalKeys} total keys, ${overrideCount} overrides, ${totalDuration}ms total`);\r\n    }\r\n\r\n    // Validate if schema is provided and validation is enabled\r\n    if (this._options.schema && this._options.validateOnLoad) {\r\n      const result = this._options.schema.safeParse(mergedConfig);\r\n      if (!result.success) {\r\n        const zodError = result.error as ZodError;\r\n        throw new ValidationError(\r\n          `Configuration validation failed: ${zodError.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`,\r\n          zodError.errors,\r\n          undefined\r\n        );\r\n      }\r\n      this.config = result.data as T;\r\n    } else {\r\n      this.config = mergedConfig as T;\r\n    }\r\n\r\n    this.loadResult = {\r\n      config: this.config,\r\n      sources,\r\n      loadedAt: new Date(),\r\n    };\r\n\r\n    this.loaded = true;\r\n  }\r\n\r\n\r\n  /**\r\n   * Get a specific configuration value by key.\r\n   * @param key The configuration key\r\n   * @returns The configuration value\r\n   * @throws ConfigurationError if configuration is not loaded\r\n   */\r\n  get<K extends keyof T>(key: K): T[K] {\r\n    if (!this.loaded || this.config === null) {\r\n      throw new ConfigurationError('Configuration not loaded. Call load() first.');\r\n    }\r\n    // Non-null assertion is safe here because we've checked this.config !== null above\r\n    return this.config![key];\r\n  }\r\n\r\n  /**\r\n   * Get all configuration values.\r\n   * @returns The complete configuration object\r\n   * @throws ConfigurationError if configuration is not loaded\r\n   */\r\n  getAll(): T {\r\n    if (!this.loaded || this.config === null) {\r\n      throw new ConfigurationError('Configuration not loaded. Call load() first.');\r\n    }\r\n    return this.config;\r\n  }\r\n\r\n  /**\r\n   * Check if configuration has been loaded.\r\n   * @returns true if configuration is loaded\r\n   */\r\n  isLoaded(): boolean {\r\n    return this.loaded;\r\n  }\r\n\r\n  /**\r\n   * Get the current application environment.\r\n   * @returns The APP_ENV value or 'development' as default\r\n   */\r\n  getAppEnv(): string {\r\n    return process.env['APP_ENV'] ?? 'development';\r\n  }\r\n\r\n  /**\r\n   * Get the load result with source information.\r\n   * @returns The load result or null if not loaded\r\n   */\r\n  getLoadResult(): ConfigLoadResult<T> | null {\r\n    return this.loadResult;\r\n  }\r\n\r\n  /**\r\n   * Serialize the current configuration to JSON string.\r\n   * @returns JSON string representation of the configuration\r\n   * @throws ConfigurationError if configuration is not loaded\r\n   */\r\n  serialize(): string {\r\n    if (!this.loaded || this.config === null) {\r\n      throw new ConfigurationError('Configuration not loaded. Call load() first.');\r\n    }\r\n    return JSON.stringify(this.config);\r\n  }\r\n\r\n  /**\r\n   * Create a new ConfigManager with configuration loaded from a JSON string.\r\n   * This is useful for restoring configuration from a serialized state.\r\n   * @param json JSON string to deserialize\r\n   * @param options Optional ConfigManager options (schema will be used for validation)\r\n   * @returns A new ConfigManager instance with the deserialized configuration\r\n   */\r\n  static deserialize<T = Record<string, unknown>>(\r\n    json: string,\r\n    options: ConfigManagerOptions<T> = {}\r\n  ): ConfigManager<T> {\r\n    const parsed = JSON.parse(json);\r\n\r\n    // Validate if schema is provided\r\n    if (options.schema) {\r\n      const result = options.schema.safeParse(parsed);\r\n      if (!result.success) {\r\n        const zodError = result.error as ZodError;\r\n        throw new ValidationError(\r\n          `Deserialization validation failed: ${zodError.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`,\r\n          zodError.errors,\r\n          undefined\r\n        );\r\n      }\r\n    }\r\n\r\n    // Create a new ConfigManager and set its internal state\r\n    const manager = new ConfigManager<T>(options);\r\n    manager.config = parsed as T;\r\n    manager.loaded = true;\r\n    manager.loadResult = {\r\n      config: parsed as T,\r\n      sources: [{ loader: 'deserialize', keysLoaded: Object.keys(parsed), duration: 0 }],\r\n      loadedAt: new Date(),\r\n    };\r\n\r\n    return manager;\r\n  }\r\n}\r\n"]}

package/dist/esm/config-aws/src/errors/index.js

@@ -0,0 +1,69 @@
+/**
+ * Base error class for all configuration-related errors
+ */
+export class ConfigurationError extends Error {
+    /** The underlying cause of this error */
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'ConfigurationError';
+        this.cause = cause;
+        Object.setPrototypeOf(this, ConfigurationError.prototype);
+    }
+}
+/**
+ * Error thrown when configuration validation fails
+ */
+export class ValidationError extends ConfigurationError {
+    /** Detailed validation errors from Zod */
+    validationErrors;
+    constructor(message, validationErrors, cause) {
+        super(message, cause);
+        this.name = 'ValidationError';
+        this.validationErrors = validationErrors;
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+/**
+ * Error thrown when an AWS service operation fails
+ */
+export class AWSServiceError extends ConfigurationError {
+    /** The AWS service that failed */
+    service;
+    /** The operation that failed */
+    operation;
+    constructor(message, service, operation, cause) {
+        super(message, cause);
+        this.name = 'AWSServiceError';
+        this.service = service;
+        this.operation = operation;
+        Object.setPrototypeOf(this, AWSServiceError.prototype);
+    }
+}
+/**
+ * Error thrown when a configuration loader fails to load
+ */
+export class ConfigurationLoadError extends ConfigurationError {
+    /** The name of the loader that failed */
+    loader;
+    constructor(message, loader, cause) {
+        super(message, cause);
+        this.name = 'ConfigurationLoadError';
+        this.loader = loader;
+        Object.setPrototypeOf(this, ConfigurationLoadError.prototype);
+    }
+}
+/**
+ * Error thrown when required configuration keys are missing
+ */
+export class MissingConfigurationError extends ConfigurationError {
+    /** The keys that are missing */
+    missingKeys;
+    constructor(message, missingKeys, cause) {
+        super(message, cause);
+        this.name = 'MissingConfigurationError';
+        this.missingKeys = missingKeys;
+        Object.setPrototypeOf(this, MissingConfigurationError.prototype);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9jb25maWctYXdzL3NyYy9lcnJvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsS0FBSztJQUMzQyx5Q0FBeUM7SUFDekIsS0FBSyxDQUFTO0lBRTlCLFlBQVksT0FBZSxFQUFFLEtBQWE7UUFDeEMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxvQkFBb0IsQ0FBQztRQUNqQyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSxrQkFBa0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM1RCxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxlQUFnQixTQUFRLGtCQUFrQjtJQUNyRCwwQ0FBMEM7SUFDMUIsZ0JBQWdCLENBQVU7SUFFMUMsWUFBWSxPQUFlLEVBQUUsZ0JBQXlCLEVBQUUsS0FBYTtRQUNuRSxLQUFLLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7UUFDOUIsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGdCQUFnQixDQUFDO1FBQ3pDLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUN6RCxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxlQUFnQixTQUFRLGtCQUFrQjtJQUNyRCxrQ0FBa0M7SUFDbEIsT0FBTyxDQUFTO0lBQ2hDLGdDQUFnQztJQUNoQixTQUFTLENBQVM7SUFFbEMsWUFBWSxPQUFlLEVBQUUsT0FBZSxFQUFFLFNBQWlCLEVBQUUsS0FBYTtRQUM1RSxLQUFLLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7UUFDOUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsZUFBZSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3pELENBQUM7Q0FDRjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLHNCQUF1QixTQUFRLGtCQUFrQjtJQUM1RCx5Q0FBeUM7SUFDekIsTUFBTSxDQUFTO0lBRS9CLFlBQVksT0FBZSxFQUFFLE1BQWMsRUFBRSxLQUFhO1FBQ3hELEtBQUssQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDdEIsSUFBSSxDQUFDLElBQUksR0FBRyx3QkFBd0IsQ0FBQztRQUNyQyxJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSxzQkFBc0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNoRSxDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyx5QkFBMEIsU0FBUSxrQkFBa0I7SUFDL0QsZ0NBQWdDO0lBQ2hCLFdBQVcsQ0FBVztJQUV0QyxZQUFZLE9BQWUsRUFBRSxXQUFxQixFQUFFLEtBQWE7UUFDL0QsS0FBSyxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsQ0FBQztRQUN0QixJQUFJLENBQUMsSUFBSSxHQUFHLDJCQUEyQixDQUFDO1FBQ3hDLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLHlCQUF5QixDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ25FLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBCYXNlIGVycm9yIGNsYXNzIGZvciBhbGwgY29uZmlndXJhdGlvbi1yZWxhdGVkIGVycm9yc1xyXG4gKi9cclxuZXhwb3J0IGNsYXNzIENvbmZpZ3VyYXRpb25FcnJvciBleHRlbmRzIEVycm9yIHtcclxuICAvKiogVGhlIHVuZGVybHlpbmcgY2F1c2Ugb2YgdGhpcyBlcnJvciAqL1xyXG4gIHB1YmxpYyByZWFkb25seSBjYXVzZT86IEVycm9yO1xyXG5cclxuICBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcsIGNhdXNlPzogRXJyb3IpIHtcclxuICAgIHN1cGVyKG1lc3NhZ2UpO1xyXG4gICAgdGhpcy5uYW1lID0gJ0NvbmZpZ3VyYXRpb25FcnJvcic7XHJcbiAgICB0aGlzLmNhdXNlID0gY2F1c2U7XHJcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgQ29uZmlndXJhdGlvbkVycm9yLnByb3RvdHlwZSk7XHJcbiAgfVxyXG59XHJcblxyXG4vKipcclxuICogRXJyb3IgdGhyb3duIHdoZW4gY29uZmlndXJhdGlvbiB2YWxpZGF0aW9uIGZhaWxzXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgVmFsaWRhdGlvbkVycm9yIGV4dGVuZHMgQ29uZmlndXJhdGlvbkVycm9yIHtcclxuICAvKiogRGV0YWlsZWQgdmFsaWRhdGlvbiBlcnJvcnMgZnJvbSBab2QgKi9cclxuICBwdWJsaWMgcmVhZG9ubHkgdmFsaWRhdGlvbkVycm9yczogdW5rbm93bjtcclxuXHJcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCB2YWxpZGF0aW9uRXJyb3JzOiB1bmtub3duLCBjYXVzZT86IEVycm9yKSB7XHJcbiAgICBzdXBlcihtZXNzYWdlLCBjYXVzZSk7XHJcbiAgICB0aGlzLm5hbWUgPSAnVmFsaWRhdGlvbkVycm9yJztcclxuICAgIHRoaXMudmFsaWRhdGlvbkVycm9ycyA9IHZhbGlkYXRpb25FcnJvcnM7XHJcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgVmFsaWRhdGlvbkVycm9yLnByb3RvdHlwZSk7XHJcbiAgfVxyXG59XHJcblxyXG4vKipcclxuICogRXJyb3IgdGhyb3duIHdoZW4gYW4gQVdTIHNlcnZpY2Ugb3BlcmF0aW9uIGZhaWxzXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgQVdTU2VydmljZUVycm9yIGV4dGVuZHMgQ29uZmlndXJhdGlvbkVycm9yIHtcclxuICAvKiogVGhlIEFXUyBzZXJ2aWNlIHRoYXQgZmFpbGVkICovXHJcbiAgcHVibGljIHJlYWRvbmx5IHNlcnZpY2U6IHN0cmluZztcclxuICAvKiogVGhlIG9wZXJhdGlvbiB0aGF0IGZhaWxlZCAqL1xyXG4gIHB1YmxpYyByZWFkb25seSBvcGVyYXRpb246IHN0cmluZztcclxuXHJcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCBzZXJ2aWNlOiBzdHJpbmcsIG9wZXJhdGlvbjogc3RyaW5nLCBjYXVzZT86IEVycm9yKSB7XHJcbiAgICBzdXBlcihtZXNzYWdlLCBjYXVzZSk7XHJcbiAgICB0aGlzLm5hbWUgPSAnQVdTU2VydmljZUVycm9yJztcclxuICAgIHRoaXMuc2VydmljZSA9IHNlcnZpY2U7XHJcbiAgICB0aGlzLm9wZXJhdGlvbiA9IG9wZXJhdGlvbjtcclxuICAgIE9iamVjdC5zZXRQcm90b3R5cGVPZih0aGlzLCBBV1NTZXJ2aWNlRXJyb3IucHJvdG90eXBlKTtcclxuICB9XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBFcnJvciB0aHJvd24gd2hlbiBhIGNvbmZpZ3VyYXRpb24gbG9hZGVyIGZhaWxzIHRvIGxvYWRcclxuICovXHJcbmV4cG9ydCBjbGFzcyBDb25maWd1cmF0aW9uTG9hZEVycm9yIGV4dGVuZHMgQ29uZmlndXJhdGlvbkVycm9yIHtcclxuICAvKiogVGhlIG5hbWUgb2YgdGhlIGxvYWRlciB0aGF0IGZhaWxlZCAqL1xyXG4gIHB1YmxpYyByZWFkb25seSBsb2FkZXI6IHN0cmluZztcclxuXHJcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCBsb2FkZXI6IHN0cmluZywgY2F1c2U/OiBFcnJvcikge1xyXG4gICAgc3VwZXIobWVzc2FnZSwgY2F1c2UpO1xyXG4gICAgdGhpcy5uYW1lID0gJ0NvbmZpZ3VyYXRpb25Mb2FkRXJyb3InO1xyXG4gICAgdGhpcy5sb2FkZXIgPSBsb2FkZXI7XHJcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgQ29uZmlndXJhdGlvbkxvYWRFcnJvci5wcm90b3R5cGUpO1xyXG4gIH1cclxufVxyXG5cclxuLyoqXHJcbiAqIEVycm9yIHRocm93biB3aGVuIHJlcXVpcmVkIGNvbmZpZ3VyYXRpb24ga2V5cyBhcmUgbWlzc2luZ1xyXG4gKi9cclxuZXhwb3J0IGNsYXNzIE1pc3NpbmdDb25maWd1cmF0aW9uRXJyb3IgZXh0ZW5kcyBDb25maWd1cmF0aW9uRXJyb3Ige1xyXG4gIC8qKiBUaGUga2V5cyB0aGF0IGFyZSBtaXNzaW5nICovXHJcbiAgcHVibGljIHJlYWRvbmx5IG1pc3NpbmdLZXlzOiBzdHJpbmdbXTtcclxuXHJcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCBtaXNzaW5nS2V5czogc3RyaW5nW10sIGNhdXNlPzogRXJyb3IpIHtcclxuICAgIHN1cGVyKG1lc3NhZ2UsIGNhdXNlKTtcclxuICAgIHRoaXMubmFtZSA9ICdNaXNzaW5nQ29uZmlndXJhdGlvbkVycm9yJztcclxuICAgIHRoaXMubWlzc2luZ0tleXMgPSBtaXNzaW5nS2V5cztcclxuICAgIE9iamVjdC5zZXRQcm90b3R5cGVPZih0aGlzLCBNaXNzaW5nQ29uZmlndXJhdGlvbkVycm9yLnByb3RvdHlwZSk7XHJcbiAgfVxyXG59XHJcbiJdfQ==