@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

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

@@ -0,0 +1,21 @@
+/**
+ * @dyanet/config-aws
+ *
+ * Framework-agnostic AWS configuration management library.
+ * Supports environment variables, AWS Secrets Manager, SSM Parameter Store,
+ * S3, and .env files with configurable precedence.
+ */
+// Error classes
+export { ConfigurationError, ValidationError, AWSServiceError, ConfigurationLoadError, MissingConfigurationError, } from './errors';
+// Loaders
+export { EnvironmentLoader } from './loaders/environment.loader';
+export { EnvFileLoader } from './loaders/env-file.loader';
+export { S3Loader } from './loaders/s3.loader';
+export { SecretsManagerLoader } from './loaders/secrets-manager.loader';
+export { SSMParameterStoreLoader } from './loaders/ssm-parameter-store.loader';
+// ConfigManager
+export { ConfigManager } from './config-manager';
+// Utilities
+export { ConfigValidationUtil } from './utils/validation.util';
+export { EnvFileParser } from './utils/env-file-parser.util';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLWxvYWRlci5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9jb25maWctYXdzL3NyYy9pbnRlcmZhY2VzL2NvbmZpZy1sb2FkZXIuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogUmVzdWx0IHJldHVybmVkIGJ5IGEgY29uZmlndXJhdGlvbiBsb2FkZXJcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnTG9hZGVyUmVzdWx0IHtcclxuICAvKiogVGhlIGxvYWRlZCBjb25maWd1cmF0aW9uIGtleS12YWx1ZSBwYWlycyAqL1xyXG4gIGNvbmZpZzogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XHJcbiAgLyoqIEtleXMgdGhhdCB3ZXJlIGxvYWRlZCBieSB0aGlzIGxvYWRlciAqL1xyXG4gIGtleXNMb2FkZWQ6IHN0cmluZ1tdO1xyXG4gIC8qKiBUaW1lIHRha2VuIHRvIGxvYWQgaW4gbWlsbGlzZWNvbmRzICovXHJcbiAgZHVyYXRpb246IG51bWJlcjtcclxufVxyXG5cclxuLyoqXHJcbiAqIEludGVyZmFjZSBmb3IgY29uZmlndXJhdGlvbiBsb2FkZXJzLlxyXG4gKiBBbGwgbG9hZGVycyBtdXN0IGltcGxlbWVudCB0aGlzIGludGVyZmFjZSB0byBiZSB1c2VkIHdpdGggQ29uZmlnTWFuYWdlci5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnTG9hZGVyIHtcclxuICAvKipcclxuICAgKiBMb2FkIGNvbmZpZ3VyYXRpb24gZnJvbSB0aGUgc291cmNlLlxyXG4gICAqIEByZXR1cm5zIFByb21pc2UgcmVzb2x2aW5nIHRvIHRoZSBsb2FkZWQgY29uZmlndXJhdGlvblxyXG4gICAqL1xyXG4gIGxvYWQoKTogUHJvbWlzZTxSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj47XHJcblxyXG4gIC8qKlxyXG4gICAqIEdldCB0aGUgbmFtZSBvZiB0aGlzIGxvYWRlciBmb3IgbG9nZ2luZyBhbmQgZGVidWdnaW5nLlxyXG4gICAqIEByZXR1cm5zIFRoZSBsb2FkZXIgbmFtZVxyXG4gICAqL1xyXG4gIGdldE5hbWUoKTogc3RyaW5nO1xyXG5cclxuICAvKipcclxuICAgKiBDaGVjayBpZiB0aGlzIGxvYWRlciBpcyBhdmFpbGFibGUgYW5kIGNhbiBsb2FkIGNvbmZpZ3VyYXRpb24uXHJcbiAgICogQHJldHVybnMgUHJvbWlzZSByZXNvbHZpbmcgdG8gdHJ1ZSBpZiB0aGUgbG9hZGVyIGNhbiBsb2FkIGNvbmZpZ3VyYXRpb25cclxuICAgKi9cclxuICBpc0F2YWlsYWJsZSgpOiBQcm9taXNlPGJvb2xlYW4+O1xyXG59XHJcbiJdfQ==

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

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

package/dist/esm/config-aws/src/interfaces/env-file-loader.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LWZpbGUtbG9hZGVyLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2NvbmZpZy1hd3Mvc3JjL2ludGVyZmFjZXMvZW52LWZpbGUtbG9hZGVyLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIENvbmZpZ3VyYXRpb24gb3B0aW9ucyBmb3IgRW52RmlsZUxvYWRlclxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBFbnZGaWxlTG9hZGVyQ29uZmlnIHtcclxuICAvKiogUGF0aHMgdG8gLmVudiBmaWxlcyB0byBsb2FkLiBEZWZhdWx0OiBbJy5lbnYnLCAnLmVudi5sb2NhbCddICovXHJcbiAgcGF0aHM/OiBzdHJpbmdbXTtcclxuICAvKiogRmlsZSBlbmNvZGluZy4gRGVmYXVsdDogJ3V0Zi04JyAqL1xyXG4gIGVuY29kaW5nPzogQnVmZmVyRW5jb2Rpbmc7XHJcbiAgLyoqIFdoZXRoZXIgbGF0ZXIgZmlsZXMgb3ZlcnJpZGUgZWFybGllciBvbmVzLiBEZWZhdWx0OiB0cnVlICovXHJcbiAgb3ZlcnJpZGU/OiBib29sZWFuO1xyXG59XHJcbiJdfQ==

package/dist/esm/config-aws/src/interfaces/environment-loader.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQtbG9hZGVyLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2NvbmZpZy1hd3Mvc3JjL2ludGVyZmFjZXMvZW52aXJvbm1lbnQtbG9hZGVyLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIENvbmZpZ3VyYXRpb24gb3B0aW9ucyBmb3IgRW52aXJvbm1lbnRMb2FkZXJcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgRW52aXJvbm1lbnRMb2FkZXJDb25maWcge1xyXG4gIC8qKiBQcmVmaXggdG8gZmlsdGVyIGVudmlyb25tZW50IHZhcmlhYmxlcy4gT25seSB2YXJpYWJsZXMgc3RhcnRpbmcgd2l0aCB0aGlzIHByZWZpeCB3aWxsIGJlIGxvYWRlZC4gKi9cclxuICBwcmVmaXg/OiBzdHJpbmc7XHJcbiAgLyoqIExpc3Qgb2YgZW52aXJvbm1lbnQgdmFyaWFibGUgbmFtZXMgdG8gZXhjbHVkZSBmcm9tIGxvYWRpbmcgKi9cclxuICBleGNsdWRlPzogc3RyaW5nW107XHJcbn1cclxuIl19

package/dist/esm/config-aws/src/interfaces/s3-loader.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiczMtbG9hZGVyLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2NvbmZpZy1hd3Mvc3JjL2ludGVyZmFjZXMvczMtbG9hZGVyLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIENvbmZpZ3VyYXRpb24gb3B0aW9ucyBmb3IgUzNMb2FkZXJcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgUzNMb2FkZXJDb25maWcge1xyXG4gIC8qKiBTMyBidWNrZXQgbmFtZSAqL1xyXG4gIGJ1Y2tldDogc3RyaW5nO1xyXG4gIC8qKiBTMyBvYmplY3Qga2V5ICovXHJcbiAga2V5OiBzdHJpbmc7XHJcbiAgLyoqIEFXUyByZWdpb24uIElmIG5vdCBzcGVjaWZpZWQsIHVzZXMgZGVmYXVsdCByZWdpb24gZnJvbSBlbnZpcm9ubWVudCAqL1xyXG4gIHJlZ2lvbj86IHN0cmluZztcclxuICAvKiogRm9ybWF0IG9mIHRoZSBjb25maWd1cmF0aW9uIGZpbGUuIERlZmF1bHQ6ICdhdXRvJyAoYXV0by1kZXRlY3QgYmFzZWQgb24gY29udGVudCkgKi9cclxuICBmb3JtYXQ/OiAnanNvbicgfCAnZW52JyB8ICdhdXRvJztcclxufVxyXG4iXX0=

package/dist/esm/config-aws/src/interfaces/secrets-manager-loader.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcmV0cy1tYW5hZ2VyLWxvYWRlci5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9jb25maWctYXdzL3NyYy9pbnRlcmZhY2VzL3NlY3JldHMtbWFuYWdlci1sb2FkZXIuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQ29uZmlndXJhdGlvbiBvcHRpb25zIGZvciBTZWNyZXRzTWFuYWdlckxvYWRlclxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBTZWNyZXRzTWFuYWdlckxvYWRlckNvbmZpZyB7XHJcbiAgLyoqIE5hbWUgb3IgQVJOIG9mIHRoZSBzZWNyZXQgdG8gbG9hZCAqL1xyXG4gIHNlY3JldE5hbWU/OiBzdHJpbmc7XHJcbiAgLyoqIEFXUyByZWdpb24uIElmIG5vdCBzcGVjaWZpZWQsIHVzZXMgZGVmYXVsdCByZWdpb24gZnJvbSBlbnZpcm9ubWVudCAqL1xyXG4gIHJlZ2lvbj86IHN0cmluZztcclxuICAvKiogTWFwcGluZyBvZiBlbnZpcm9ubWVudCBuYW1lcyB0byBwYXRoIHByZWZpeGVzICovXHJcbiAgZW52aXJvbm1lbnRNYXBwaW5nPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcclxufVxyXG4iXX0=

package/dist/esm/config-aws/src/interfaces/ssm-parameter-store-loader.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NtLXBhcmFtZXRlci1zdG9yZS1sb2FkZXIuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vY29uZmlnLWF3cy9zcmMvaW50ZXJmYWNlcy9zc20tcGFyYW1ldGVyLXN0b3JlLWxvYWRlci5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBDb25maWd1cmF0aW9uIG9wdGlvbnMgZm9yIFNTTVBhcmFtZXRlclN0b3JlTG9hZGVyXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFNTTVBhcmFtZXRlclN0b3JlTG9hZGVyQ29uZmlnIHtcclxuICAvKiogUGF0aCBwcmVmaXggZm9yIHBhcmFtZXRlcnMgdG8gbG9hZCAqL1xyXG4gIHBhcmFtZXRlclBhdGg/OiBzdHJpbmc7XHJcbiAgLyoqIEFXUyByZWdpb24uIElmIG5vdCBzcGVjaWZpZWQsIHVzZXMgZGVmYXVsdCByZWdpb24gZnJvbSBlbnZpcm9ubWVudCAqL1xyXG4gIHJlZ2lvbj86IHN0cmluZztcclxuICAvKiogTWFwcGluZyBvZiBlbnZpcm9ubWVudCBuYW1lcyB0byBwYXRoIHByZWZpeGVzICovXHJcbiAgZW52aXJvbm1lbnRNYXBwaW5nPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcclxuICAvKiogV2hldGhlciB0byBkZWNyeXB0IFNlY3VyZVN0cmluZyBwYXJhbWV0ZXJzLiBEZWZhdWx0OiB0cnVlICovXHJcbiAgd2l0aERlY3J5cHRpb24/OiBib29sZWFuO1xyXG59XHJcbiJdfQ==

package/dist/esm/config-aws/src/loaders/env-file.loader.js

@@ -0,0 +1,132 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { EnvFileParser } from '../utils/env-file-parser.util';
+import { ConfigurationLoadError } from '../errors';
+/**
+ * Loader that reads configuration from .env files on the filesystem.
+ * Uses AWS ECS-compatible format for parsing.
+ *
+ * @example
+ * ```typescript
+ * // Load from default paths (.env, .env.local)
+ * const loader = new EnvFileLoader();
+ *
+ * // Load from specific paths
+ * const loader = new EnvFileLoader({
+ *   paths: ['.env', '.env.production']
+ * });
+ *
+ * // Disable override (first file wins)
+ * const loader = new EnvFileLoader({
+ *   paths: ['.env', '.env.local'],
+ *   override: false
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html
+ */
+export class EnvFileLoader {
+    /** @internal */
+    _config;
+    /** Default paths to search for .env files */
+    static DEFAULT_PATHS = ['.env', '.env.local'];
+    /** Default file encoding */
+    static DEFAULT_ENCODING = 'utf-8';
+    constructor(config = {}) {
+        this._config = {
+            paths: config.paths ?? EnvFileLoader.DEFAULT_PATHS,
+            encoding: config.encoding ?? EnvFileLoader.DEFAULT_ENCODING,
+            override: config.override ?? true,
+        };
+    }
+    getName() {
+        return 'EnvFileLoader';
+    }
+    /**
+     * Check if at least one of the configured .env files exists.
+     * @returns Promise resolving to true if any file exists
+     */
+    async isAvailable() {
+        for (const filePath of this._config.paths) {
+            const resolvedPath = this.resolvePath(filePath);
+            if (await this.fileExists(resolvedPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Load configuration from .env files.
+     *
+     * Files are processed in order. When override is true (default),
+     * later files override earlier ones. When override is false,
+     * earlier files take precedence.
+     *
+     * Missing files are silently skipped.
+     *
+     * @returns Promise resolving to the merged configuration
+     * @throws ConfigurationLoadError if a file exists but cannot be read
+     */
+    async load() {
+        const result = {};
+        for (const filePath of this._config.paths) {
+            const resolvedPath = this.resolvePath(filePath);
+            if (!(await this.fileExists(resolvedPath))) {
+                // Skip missing files silently
+                continue;
+            }
+            try {
+                const content = await this.readFile(resolvedPath);
+                const parsed = EnvFileParser.parse(content);
+                // Merge based on override setting
+                if (this._config.override) {
+                    // Later files override earlier ones
+                    Object.assign(result, parsed);
+                }
+                else {
+                    // Earlier files take precedence - only add keys that don't exist
+                    for (const [key, value] of Object.entries(parsed)) {
+                        if (!(key in result)) {
+                            result[key] = value;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                throw new ConfigurationLoadError(`Failed to read env file: ${resolvedPath}`, this.getName(), error instanceof Error ? error : undefined);
+            }
+        }
+        return result;
+    }
+    /**
+     * Resolve a file path relative to the current working directory.
+     * @internal
+     */
+    resolvePath(filePath) {
+        if (path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        return path.resolve(process.cwd(), filePath);
+    }
+    /**
+     * Check if a file exists.
+     * @internal
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.promises.access(filePath, fs.constants.R_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Read a file's contents.
+     * @internal
+     */
+    async readFile(filePath) {
+        return fs.promises.readFile(filePath, { encoding: this._config.encoding });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-file.loader.js","sourceRoot":"","sources":["../../../../../../config-aws/src/loaders/env-file.loader.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\r\nimport * as path from 'path';\r\nimport type { ConfigLoader } from '../interfaces/config-loader.interface';\r\nimport type { EnvFileLoaderConfig } from '../interfaces/env-file-loader.interface';\r\nimport { EnvFileParser } from '../utils/env-file-parser.util';\r\nimport { ConfigurationLoadError } from '../errors';\r\n\r\n/**\r\n * Loader that reads configuration from .env files on the filesystem.\r\n * Uses AWS ECS-compatible format for parsing.\r\n *\r\n * @example\r\n * ```typescript\r\n * // Load from default paths (.env, .env.local)\r\n * const loader = new EnvFileLoader();\r\n *\r\n * // Load from specific paths\r\n * const loader = new EnvFileLoader({\r\n *   paths: ['.env', '.env.production']\r\n * });\r\n *\r\n * // Disable override (first file wins)\r\n * const loader = new EnvFileLoader({\r\n *   paths: ['.env', '.env.local'],\r\n *   override: false\r\n * });\r\n * ```\r\n *\r\n * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html\r\n */\r\nexport class EnvFileLoader implements ConfigLoader {\r\n  /** @internal */\r\n  protected readonly _config: Required<EnvFileLoaderConfig>;\r\n\r\n  /** Default paths to search for .env files */\r\n  private static readonly DEFAULT_PATHS = ['.env', '.env.local'];\r\n\r\n  /** Default file encoding */\r\n  private static readonly DEFAULT_ENCODING: BufferEncoding = 'utf-8';\r\n\r\n  constructor(config: EnvFileLoaderConfig = {}) {\r\n    this._config = {\r\n      paths: config.paths ?? EnvFileLoader.DEFAULT_PATHS,\r\n      encoding: config.encoding ?? EnvFileLoader.DEFAULT_ENCODING,\r\n      override: config.override ?? true,\r\n    };\r\n  }\r\n\r\n  getName(): string {\r\n    return 'EnvFileLoader';\r\n  }\r\n\r\n\r\n  /**\r\n   * Check if at least one of the configured .env files exists.\r\n   * @returns Promise resolving to true if any file exists\r\n   */\r\n  async isAvailable(): Promise<boolean> {\r\n    for (const filePath of this._config.paths) {\r\n      const resolvedPath = this.resolvePath(filePath);\r\n      if (await this.fileExists(resolvedPath)) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Load configuration from .env files.\r\n   *\r\n   * Files are processed in order. When override is true (default),\r\n   * later files override earlier ones. When override is false,\r\n   * earlier files take precedence.\r\n   *\r\n   * Missing files are silently skipped.\r\n   *\r\n   * @returns Promise resolving to the merged configuration\r\n   * @throws ConfigurationLoadError if a file exists but cannot be read\r\n   */\r\n  async load(): Promise<Record<string, unknown>> {\r\n    const result: Record<string, unknown> = {};\r\n\r\n    for (const filePath of this._config.paths) {\r\n      const resolvedPath = this.resolvePath(filePath);\r\n\r\n      if (!(await this.fileExists(resolvedPath))) {\r\n        // Skip missing files silently\r\n        continue;\r\n      }\r\n\r\n      try {\r\n        const content = await this.readFile(resolvedPath);\r\n        const parsed = EnvFileParser.parse(content);\r\n\r\n        // Merge based on override setting\r\n        if (this._config.override) {\r\n          // Later files override earlier ones\r\n          Object.assign(result, parsed);\r\n        } else {\r\n          // Earlier files take precedence - only add keys that don't exist\r\n          for (const [key, value] of Object.entries(parsed)) {\r\n            if (!(key in result)) {\r\n              result[key] = value;\r\n            }\r\n          }\r\n        }\r\n      } catch (error) {\r\n        throw new ConfigurationLoadError(\r\n          `Failed to read env file: ${resolvedPath}`,\r\n          this.getName(),\r\n          error instanceof Error ? error : undefined,\r\n        );\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Resolve a file path relative to the current working directory.\r\n   * @internal\r\n   */\r\n  protected resolvePath(filePath: string): string {\r\n    if (path.isAbsolute(filePath)) {\r\n      return filePath;\r\n    }\r\n    return path.resolve(process.cwd(), filePath);\r\n  }\r\n\r\n  /**\r\n   * Check if a file exists.\r\n   * @internal\r\n   */\r\n  protected async fileExists(filePath: string): Promise<boolean> {\r\n    try {\r\n      await fs.promises.access(filePath, fs.constants.R_OK);\r\n      return true;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Read a file's contents.\r\n   * @internal\r\n   */\r\n  protected async readFile(filePath: string): Promise<string> {\r\n    return fs.promises.readFile(filePath, { encoding: this._config.encoding });\r\n  }\r\n}\r\n"]}

package/dist/esm/config-aws/src/loaders/environment.loader.js

@@ -0,0 +1,81 @@
+/**
+ * Loader that reads configuration from process.env.
+ * Supports prefix filtering and exclusion lists.
+ *
+ * @example
+ * ```typescript
+ * // Load all environment variables
+ * const loader = new EnvironmentLoader();
+ *
+ * // Load only variables starting with 'APP_', stripping the prefix
+ * const loader = new EnvironmentLoader({ prefix: 'APP_' });
+ *
+ * // Load all except specific variables
+ * const loader = new EnvironmentLoader({ exclude: ['PATH', 'HOME'] });
+ *
+ * // Combine prefix and exclusion
+ * const loader = new EnvironmentLoader({
+ *   prefix: 'APP_',
+ *   exclude: ['APP_DEBUG']
+ * });
+ * ```
+ */
+export class EnvironmentLoader {
+    /** @internal */
+    _config;
+    constructor(config = {}) {
+        this._config = config;
+    }
+    getName() {
+        return 'EnvironmentLoader';
+    }
+    async isAvailable() {
+        return true;
+    }
+    /**
+     * Load configuration from process.env.
+     *
+     * When a prefix is specified:
+     * - Only variables starting with the prefix are included
+     * - The prefix is stripped from the resulting key names
+     *
+     * When an exclusion list is specified:
+     * - Variables in the list are excluded from the result
+     * - Exclusion is checked against the original key (before prefix stripping)
+     *
+     * @returns Promise resolving to the loaded configuration
+     */
+    async load() {
+        const result = {};
+        const { prefix, exclude = [] } = this._config;
+        const excludeSet = new Set(exclude);
+        for (const [key, value] of Object.entries(process.env)) {
+            // Skip undefined values
+            if (value === undefined) {
+                continue;
+            }
+            // Check exclusion list (against original key)
+            if (excludeSet.has(key)) {
+                continue;
+            }
+            // Handle prefix filtering
+            if (prefix) {
+                if (key.startsWith(prefix)) {
+                    // Strip prefix from key
+                    const strippedKey = key.slice(prefix.length);
+                    // Only include if there's a key remaining after stripping
+                    if (strippedKey) {
+                        result[strippedKey] = value;
+                    }
+                }
+                // Skip keys that don't match the prefix
+            }
+            else {
+                // No prefix - include all non-excluded keys
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/config-aws/src/loaders/s3.loader.js

@@ -0,0 +1,141 @@
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { EnvFileParser } from '../utils/env-file-parser.util';
+import { AWSServiceError, ConfigurationLoadError } from '../errors';
+/**
+ * Loader that reads configuration from S3 buckets.
+ * Supports JSON and .env file formats with auto-detection.
+ *
+ * @example
+ * ```typescript
+ * // Load JSON config from S3
+ * const loader = new S3Loader({
+ *   bucket: 'my-config-bucket',
+ *   key: 'config/app.json',
+ *   format: 'json'
+ * });
+ *
+ * // Load .env file from S3 with auto-detection
+ * const loader = new S3Loader({
+ *   bucket: 'my-config-bucket',
+ *   key: 'config/.env'
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html
+ */
+export class S3Loader {
+    /** @internal */
+    _config;
+    /** @internal */
+    _client;
+    constructor(config) {
+        this._config = {
+            bucket: config.bucket,
+            key: config.key,
+            region: config.region || process.env['AWS_REGION'] || 'us-east-1',
+            format: config.format || 'auto',
+        };
+        this._client = new S3Client({
+            credentials: fromNodeProviderChain(),
+            region: this._config.region,
+        });
+    }
+    getName() {
+        return `S3Loader(s3://${this._config.bucket}/${this._config.key})`;
+    }
+    /**
+     * Check if this loader is available by verifying AWS credentials.
+     * @returns Promise resolving to true if AWS credentials are available
+     */
+    async isAvailable() {
+        try {
+            await this._client.config.credentials();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Load configuration from S3.
+     * @returns Promise resolving to configuration key-value pairs
+     * @throws AWSServiceError if S3 operation fails
+     * @throws ConfigurationLoadError if content cannot be parsed
+     */
+    async load() {
+        try {
+            const command = new GetObjectCommand({
+                Bucket: this._config.bucket,
+                Key: this._config.key,
+            });
+            const response = await this._client.send(command);
+            if (!response.Body) {
+                return {};
+            }
+            const content = await response.Body.transformToString();
+            if (!content || content.trim() === '') {
+                return {};
+            }
+            return this.parseContent(content);
+        }
+        catch (error) {
+            if (error instanceof ConfigurationLoadError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                if (error.name === 'NoSuchKey' || error.name === 'NoSuchBucket') {
+                    // Object or bucket doesn't exist - return empty config
+                    return {};
+                }
+                if (error.name === 'AccessDenied') {
+                    throw new AWSServiceError(`Access denied when retrieving s3://${this._config.bucket}/${this._config.key}. Check AWS credentials and permissions.`, 'S3', 'GetObject', error);
+                }
+            }
+            throw new AWSServiceError(`Failed to retrieve s3://${this._config.bucket}/${this._config.key}: ${error instanceof Error ? error.message : String(error)}`, 'S3', 'GetObject', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Parse content based on format setting or auto-detection.
+     * @internal
+     */
+    parseContent(content) {
+        const format = this._config.format === 'auto' ? this.detectFormat(content) : this._config.format;
+        if (format === 'json') {
+            return this.parseJson(content);
+        }
+        else {
+            return EnvFileParser.parse(content);
+        }
+    }
+    /**
+     * Detect content format based on structure.
+     * JSON content starts with '{' after trimming whitespace.
+     * @internal
+     */
+    detectFormat(content) {
+        const trimmed = content.trim();
+        if (trimmed.startsWith('{')) {
+            return 'json';
+        }
+        return 'env';
+    }
+    /**
+     * Parse JSON content.
+     * @internal
+     */
+    parseJson(content) {
+        try {
+            const parsed = JSON.parse(content);
+            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            // If not an object, wrap it
+            return { CONFIG_VALUE: parsed };
+        }
+        catch (error) {
+            throw new ConfigurationLoadError(`Failed to parse JSON from s3://${this._config.bucket}/${this._config.key}: ${error instanceof Error ? error.message : String(error)}`, this.getName(), error instanceof Error ? error : undefined);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"s3.loader.js","sourceRoot":"","sources":["../../../../../../config-aws/src/loaders/s3.loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,QAAQ;IACnB,gBAAgB;IACG,OAAO,CAA2B;IACrD,gBAAgB;IACG,OAAO,CAAW;IAErC,YAAY,MAAsB;QAChC,IAAI,CAAC,OAAO,GAAG;YACb,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,WAAW;YACjE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,MAAM;SAChC,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,QAAQ,CAAC;YAC1B,WAAW,EAAE,qBAAqB,EAAE;YACpC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;SAC5B,CAAC,CAAC;IACL,CAAC;IAED,OAAO;QACL,OAAO,iBAAiB,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;IACrE,CAAC;IAGD;;;OAGG;IACH,KAAK,CAAC,WAAW;QACf,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;gBACnC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;gBAC3B,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG;aACtB,CAAC,CAAC;YAEH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAElD,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;gBACnB,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAExD,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBACtC,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,sBAAsB,EAAE,CAAC;gBAC5C,MAAM,KAAK,CAAC;YACd,CAAC;YAED,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;gBAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;oBAChE,uDAAuD;oBACvD,OAAO,EAAE,CAAC;gBACZ,CAAC;gBAED,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;oBAClC,MAAM,IAAI,eAAe,CACvB,sCAAsC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,0CAA0C,EACvH,IAAI,EACJ,WAAW,EACX,KAAK,CACN,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,MAAM,IAAI,eAAe,CACvB,2BAA2B,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAC/H,IAAI,EACJ,WAAW,EACX,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAC3C,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACO,YAAY,CAAC,OAAe;QACpC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QAEjG,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACN,OAAO,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACO,YAAY,CAAC,OAAe;QACpC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACO,SAAS,CAAC,OAAe;QACjC,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAEnC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC5E,OAAO,MAAM,CAAC;YAChB,CAAC;YAED,4BAA4B;YAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,sBAAsB,CAC9B,kCAAkC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EACtI,IAAI,CAAC,OAAO,EAAE,EACd,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAC3C,CAAC;QACJ,CAAC;IACH,CAAC;CACF","sourcesContent":["import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';\r\nimport { fromNodeProviderChain } from '@aws-sdk/credential-providers';\r\nimport type { ConfigLoader } from '../interfaces/config-loader.interface';\r\nimport type { S3LoaderConfig } from '../interfaces/s3-loader.interface';\r\nimport { EnvFileParser } from '../utils/env-file-parser.util';\r\nimport { AWSServiceError, ConfigurationLoadError } from '../errors';\r\n\r\n/**\r\n * Loader that reads configuration from S3 buckets.\r\n * Supports JSON and .env file formats with auto-detection.\r\n *\r\n * @example\r\n * ```typescript\r\n * // Load JSON config from S3\r\n * const loader = new S3Loader({\r\n *   bucket: 'my-config-bucket',\r\n *   key: 'config/app.json',\r\n *   format: 'json'\r\n * });\r\n *\r\n * // Load .env file from S3 with auto-detection\r\n * const loader = new S3Loader({\r\n *   bucket: 'my-config-bucket',\r\n *   key: 'config/.env'\r\n * });\r\n * ```\r\n *\r\n * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html\r\n */\r\nexport class S3Loader implements ConfigLoader {\r\n  /** @internal */\r\n  protected readonly _config: Required<S3LoaderConfig>;\r\n  /** @internal */\r\n  protected readonly _client: S3Client;\r\n\r\n  constructor(config: S3LoaderConfig) {\r\n    this._config = {\r\n      bucket: config.bucket,\r\n      key: config.key,\r\n      region: config.region || process.env['AWS_REGION'] || 'us-east-1',\r\n      format: config.format || 'auto',\r\n    };\r\n\r\n    this._client = new S3Client({\r\n      credentials: fromNodeProviderChain(),\r\n      region: this._config.region,\r\n    });\r\n  }\r\n\r\n  getName(): string {\r\n    return `S3Loader(s3://${this._config.bucket}/${this._config.key})`;\r\n  }\r\n\r\n\r\n  /**\r\n   * Check if this loader is available by verifying AWS credentials.\r\n   * @returns Promise resolving to true if AWS credentials are available\r\n   */\r\n  async isAvailable(): Promise<boolean> {\r\n    try {\r\n      await this._client.config.credentials();\r\n      return true;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load configuration from S3.\r\n   * @returns Promise resolving to configuration key-value pairs\r\n   * @throws AWSServiceError if S3 operation fails\r\n   * @throws ConfigurationLoadError if content cannot be parsed\r\n   */\r\n  async load(): Promise<Record<string, unknown>> {\r\n    try {\r\n      const command = new GetObjectCommand({\r\n        Bucket: this._config.bucket,\r\n        Key: this._config.key,\r\n      });\r\n\r\n      const response = await this._client.send(command);\r\n\r\n      if (!response.Body) {\r\n        return {};\r\n      }\r\n\r\n      const content = await response.Body.transformToString();\r\n\r\n      if (!content || content.trim() === '') {\r\n        return {};\r\n      }\r\n\r\n      return this.parseContent(content);\r\n    } catch (error) {\r\n      if (error instanceof ConfigurationLoadError) {\r\n        throw error;\r\n      }\r\n\r\n      if (error instanceof Error) {\r\n        if (error.name === 'NoSuchKey' || error.name === 'NoSuchBucket') {\r\n          // Object or bucket doesn't exist - return empty config\r\n          return {};\r\n        }\r\n\r\n        if (error.name === 'AccessDenied') {\r\n          throw new AWSServiceError(\r\n            `Access denied when retrieving s3://${this._config.bucket}/${this._config.key}. Check AWS credentials and permissions.`,\r\n            'S3',\r\n            'GetObject',\r\n            error,\r\n          );\r\n        }\r\n      }\r\n\r\n      throw new AWSServiceError(\r\n        `Failed to retrieve s3://${this._config.bucket}/${this._config.key}: ${error instanceof Error ? error.message : String(error)}`,\r\n        'S3',\r\n        'GetObject',\r\n        error instanceof Error ? error : undefined,\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Parse content based on format setting or auto-detection.\r\n   * @internal\r\n   */\r\n  protected parseContent(content: string): Record<string, unknown> {\r\n    const format = this._config.format === 'auto' ? this.detectFormat(content) : this._config.format;\r\n\r\n    if (format === 'json') {\r\n      return this.parseJson(content);\r\n    } else {\r\n      return EnvFileParser.parse(content);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Detect content format based on structure.\r\n   * JSON content starts with '{' after trimming whitespace.\r\n   * @internal\r\n   */\r\n  protected detectFormat(content: string): 'json' | 'env' {\r\n    const trimmed = content.trim();\r\n    if (trimmed.startsWith('{')) {\r\n      return 'json';\r\n    }\r\n    return 'env';\r\n  }\r\n\r\n  /**\r\n   * Parse JSON content.\r\n   * @internal\r\n   */\r\n  protected parseJson(content: string): Record<string, unknown> {\r\n    try {\r\n      const parsed = JSON.parse(content);\r\n\r\n      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {\r\n        return parsed;\r\n      }\r\n\r\n      // If not an object, wrap it\r\n      return { CONFIG_VALUE: parsed };\r\n    } catch (error) {\r\n      throw new ConfigurationLoadError(\r\n        `Failed to parse JSON from s3://${this._config.bucket}/${this._config.key}: ${error instanceof Error ? error.message : String(error)}`,\r\n        this.getName(),\r\n        error instanceof Error ? error : undefined,\r\n      );\r\n    }\r\n  }\r\n}\r\n"]}