@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

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

@@ -0,0 +1,292 @@
+"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 PrecedenceHandlerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrecedenceHandlerService = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Service responsible for handling configuration precedence rules and merging strategies.
+ */
+let PrecedenceHandlerService = PrecedenceHandlerService_1 = class PrecedenceHandlerService {
+    logger = new common_1.Logger(PrecedenceHandlerService_1.name);
+    /**
+     * Apply precedence rules to merge configuration from multiple sources.
+     * @param sources - Array of configuration sources
+     * @param precedenceRule - The precedence rule to apply
+     * @returns Merged configuration data
+     */
+    applyPrecedenceRules(sources, precedenceRule) {
+        this.logger.debug(`Applying precedence rule: ${precedenceRule} to ${sources.length} sources`);
+        if (sources.length === 0) {
+            return {};
+        }
+        if (sources.length === 1) {
+            return sources[0]?.data || {};
+        }
+        switch (precedenceRule) {
+            case 'aws-first':
+                return this.applyAwsFirstPrecedence(sources);
+            case 'local-first':
+                return this.applyLocalFirstPrecedence(sources);
+            case 'merge':
+                return this.applyMergePrecedence(sources);
+            default:
+                this.logger.warn(`Unknown precedence rule: ${precedenceRule}, defaulting to 'aws-first'`);
+                return this.applyAwsFirstPrecedence(sources);
+        }
+    }
+    /**
+     * Apply AWS-first precedence: AWS sources override local sources.
+     * Priority order: AWS Secrets Manager > SSM Parameter Store > Environment > Local Files
+     * @param sources - Configuration sources
+     * @returns Merged configuration
+     */
+    applyAwsFirstPrecedence(sources) {
+        this.logger.debug('Applying AWS-first precedence');
+        const sortedSources = this.sortSourcesByAwsFirstPriority(sources);
+        return this.mergeSourcesInOrder(sortedSources);
+    }
+    /**
+     * Apply local-first precedence: Local sources override AWS sources.
+     * Priority order: Local Files > Environment > SSM Parameter Store > AWS Secrets Manager
+     * @param sources - Configuration sources
+     * @returns Merged configuration
+     */
+    applyLocalFirstPrecedence(sources) {
+        this.logger.debug('Applying local-first precedence');
+        const sortedSources = this.sortSourcesByLocalFirstPriority(sources);
+        return this.mergeSourcesInOrder(sortedSources);
+    }
+    /**
+     * Apply merge precedence: Intelligent merging based on source type and priority.
+     * Uses a balanced approach where both AWS and local sources contribute.
+     * @param sources - Configuration sources
+     * @returns Merged configuration
+     */
+    applyMergePrecedence(sources) {
+        this.logger.debug('Applying merge precedence');
+        // Group sources by type
+        const sourceGroups = this.groupSourcesByType(sources);
+        // Merge within each group first
+        const mergedGroups = {};
+        for (const [type, typeSources] of Object.entries(sourceGroups)) {
+            if (typeSources.length > 0) {
+                mergedGroups[type] = this.mergeSourcesInOrder(typeSources);
+            }
+        }
+        // Then merge across groups with balanced priority
+        return this.mergeGroupsWithBalancedPriority(mergedGroups);
+    }
+    /**
+     * Sort sources by AWS-first priority.
+     * @param sources - Configuration sources
+     * @returns Sorted sources (lowest priority first, highest priority last)
+     */
+    sortSourcesByAwsFirstPriority(sources) {
+        const priorityMap = {
+            'local-file': 1,
+            'environment': 2,
+            'ssm': 3,
+            'secrets-manager': 4
+        };
+        return [...sources].sort((a, b) => {
+            const priorityA = priorityMap[a.type] || 0;
+            const priorityB = priorityMap[b.type] || 0;
+            if (priorityA !== priorityB) {
+                return priorityA - priorityB;
+            }
+            // If same type, sort by explicit priority
+            return a.priority - b.priority;
+        });
+    }
+    /**
+     * Sort sources by local-first priority.
+     * @param sources - Configuration sources
+     * @returns Sorted sources (lowest priority first, highest priority last)
+     */
+    sortSourcesByLocalFirstPriority(sources) {
+        const priorityMap = {
+            'secrets-manager': 1,
+            'ssm': 2,
+            'environment': 3,
+            'local-file': 4
+        };
+        return [...sources].sort((a, b) => {
+            const priorityA = priorityMap[a.type] || 0;
+            const priorityB = priorityMap[b.type] || 0;
+            if (priorityA !== priorityB) {
+                return priorityA - priorityB;
+            }
+            // If same type, sort by explicit priority
+            return a.priority - b.priority;
+        });
+    }
+    /**
+     * Group sources by their type.
+     * @param sources - Configuration sources
+     * @returns Sources grouped by type
+     */
+    groupSourcesByType(sources) {
+        const groups = {};
+        for (const source of sources) {
+            if (!groups[source.type]) {
+                groups[source.type] = [];
+            }
+            groups[source.type]?.push(source);
+        }
+        // Sort within each group by priority
+        for (const type in groups) {
+            groups[type]?.sort((a, b) => a.priority - b.priority);
+        }
+        return groups;
+    }
+    /**
+     * Merge sources in the given order (later sources override earlier ones).
+     * @param sources - Ordered configuration sources
+     * @returns Merged configuration
+     */
+    mergeSourcesInOrder(sources) {
+        let merged = {};
+        for (const source of sources) {
+            this.logger.debug(`Merging source: ${source.name} (${source.type})`);
+            merged = this.deepMerge(merged, source.data);
+        }
+        return merged;
+    }
+    /**
+     * Merge groups with balanced priority for merge precedence.
+     * @param groups - Configuration groups by type
+     * @returns Merged configuration
+     */
+    mergeGroupsWithBalancedPriority(groups) {
+        let merged = {};
+        // Merge in balanced order: local-file -> environment -> ssm -> secrets-manager
+        const mergeOrder = ['local-file', 'environment', 'ssm', 'secrets-manager'];
+        for (const type of mergeOrder) {
+            if (groups[type]) {
+                this.logger.debug(`Merging group: ${type}`);
+                merged = this.deepMerge(merged, groups[type]);
+            }
+        }
+        return merged;
+    }
+    /**
+     * Deep merge two configuration objects with conflict resolution.
+     * @param target - Target object (lower priority)
+     * @param source - Source object (higher priority)
+     * @returns Merged object
+     */
+    deepMerge(target, source) {
+        const result = { ...target };
+        for (const [key, value] of Object.entries(source)) {
+            if (this.shouldDeepMerge(result[key], value)) {
+                result[key] = this.deepMerge(result[key], value);
+            }
+            else {
+                result[key] = this.cloneValue(value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Determine if two values should be deep merged.
+     * @param target - Target value
+     * @param source - Source value
+     * @returns True if should deep merge, false otherwise
+     */
+    shouldDeepMerge(target, source) {
+        return target !== null &&
+            source !== null &&
+            typeof target === 'object' &&
+            typeof source === 'object' &&
+            !Array.isArray(target) &&
+            !Array.isArray(source);
+    }
+    /**
+     * Clone a value to avoid reference issues.
+     * @param value - Value to clone
+     * @returns Cloned value
+     */
+    cloneValue(value) {
+        if (value === null || typeof value !== 'object') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => this.cloneValue(item));
+        }
+        const cloned = {};
+        for (const [key, val] of Object.entries(value)) {
+            cloned[key] = this.cloneValue(val);
+        }
+        return cloned;
+    }
+    /**
+     * Validate configuration sources for precedence handling.
+     * @param sources - Configuration sources to validate
+     * @returns Validation result with any issues found
+     */
+    validateSources(sources) {
+        const issues = [];
+        if (!Array.isArray(sources)) {
+            issues.push('Sources must be an array');
+            return { valid: false, issues };
+        }
+        for (let i = 0; i < sources.length; i++) {
+            const source = sources[i];
+            if (!source) {
+                issues.push(`Source at index ${i} is null or undefined`);
+                continue;
+            }
+            if (!source.name || typeof source.name !== 'string') {
+                issues.push(`Source at index ${i} must have a valid name`);
+            }
+            if (!source.type || !['environment', 'secrets-manager', 'ssm', 'local-file'].includes(source.type)) {
+                issues.push(`Source at index ${i} must have a valid type`);
+            }
+            if (typeof source.priority !== 'number') {
+                issues.push(`Source at index ${i} must have a numeric priority`);
+            }
+            if (!source.data || typeof source.data !== 'object') {
+                issues.push(`Source at index ${i} must have valid data object`);
+            }
+            if (!source.loadedAt || !(source.loadedAt instanceof Date)) {
+                issues.push(`Source at index ${i} must have a valid loadedAt date`);
+            }
+        }
+        return { valid: issues.length === 0, issues };
+    }
+    /**
+     * Get the effective priority for a source based on precedence rule.
+     * @param source - Configuration source
+     * @param precedenceRule - Precedence rule
+     * @returns Effective priority
+     */
+    getEffectivePriority(source, precedenceRule) {
+        const basePriority = source.priority;
+        switch (precedenceRule) {
+            case 'aws-first':
+                const awsFirstBonus = source.type === 'secrets-manager' ? 1000 :
+                    source.type === 'ssm' ? 500 : 0;
+                return basePriority + awsFirstBonus;
+            case 'local-first':
+                const localFirstBonus = source.type === 'local-file' ? 1000 :
+                    source.type === 'environment' ? 500 : 0;
+                return basePriority + localFirstBonus;
+            case 'merge':
+                // In merge mode, all sources have equal weight
+                return basePriority;
+            default:
+                return basePriority;
+        }
+    }
+};
+exports.PrecedenceHandlerService = PrecedenceHandlerService;
+exports.PrecedenceHandlerService = PrecedenceHandlerService = PrecedenceHandlerService_1 = __decorate([
+    (0, common_1.Injectable)()
+], PrecedenceHandlerService);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"precedence-handler.service.js","sourceRoot":"","sources":["../../../../../../src/integration/services/precedence-handler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\r\nimport { ConfigurationSource } from '../interfaces/configuration-source.interface';\r\nimport { PrecedenceRule } from '../interfaces/integration-options.interface';\r\n\r\n/**\r\n * Service responsible for handling configuration precedence rules and merging strategies.\r\n */\r\n@Injectable()\r\nexport class PrecedenceHandlerService {\r\n  private readonly logger = new Logger(PrecedenceHandlerService.name);\r\n\r\n  /**\r\n   * Apply precedence rules to merge configuration from multiple sources.\r\n   * @param sources - Array of configuration sources\r\n   * @param precedenceRule - The precedence rule to apply\r\n   * @returns Merged configuration data\r\n   */\r\n  applyPrecedenceRules(\r\n    sources: ConfigurationSource[],\r\n    precedenceRule: PrecedenceRule\r\n  ): Record<string, any> {\r\n    this.logger.debug(`Applying precedence rule: ${precedenceRule} to ${sources.length} sources`);\r\n\r\n    if (sources.length === 0) {\r\n      return {};\r\n    }\r\n\r\n    if (sources.length === 1) {\r\n      return sources[0]?.data || {};\r\n    }\r\n\r\n    switch (precedenceRule) {\r\n      case 'aws-first':\r\n        return this.applyAwsFirstPrecedence(sources);\r\n      case 'local-first':\r\n        return this.applyLocalFirstPrecedence(sources);\r\n      case 'merge':\r\n        return this.applyMergePrecedence(sources);\r\n      default:\r\n        this.logger.warn(`Unknown precedence rule: ${precedenceRule}, defaulting to 'aws-first'`);\r\n        return this.applyAwsFirstPrecedence(sources);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apply AWS-first precedence: AWS sources override local sources.\r\n   * Priority order: AWS Secrets Manager > SSM Parameter Store > Environment > Local Files\r\n   * @param sources - Configuration sources\r\n   * @returns Merged configuration\r\n   */\r\n  private applyAwsFirstPrecedence(sources: ConfigurationSource[]): Record<string, any> {\r\n    this.logger.debug('Applying AWS-first precedence');\r\n    \r\n    const sortedSources = this.sortSourcesByAwsFirstPriority(sources);\r\n    return this.mergeSourcesInOrder(sortedSources);\r\n  }\r\n\r\n  /**\r\n   * Apply local-first precedence: Local sources override AWS sources.\r\n   * Priority order: Local Files > Environment > SSM Parameter Store > AWS Secrets Manager\r\n   * @param sources - Configuration sources\r\n   * @returns Merged configuration\r\n   */\r\n  private applyLocalFirstPrecedence(sources: ConfigurationSource[]): Record<string, any> {\r\n    this.logger.debug('Applying local-first precedence');\r\n    \r\n    const sortedSources = this.sortSourcesByLocalFirstPriority(sources);\r\n    return this.mergeSourcesInOrder(sortedSources);\r\n  }\r\n\r\n  /**\r\n   * Apply merge precedence: Intelligent merging based on source type and priority.\r\n   * Uses a balanced approach where both AWS and local sources contribute.\r\n   * @param sources - Configuration sources\r\n   * @returns Merged configuration\r\n   */\r\n  private applyMergePrecedence(sources: ConfigurationSource[]): Record<string, any> {\r\n    this.logger.debug('Applying merge precedence');\r\n    \r\n    // Group sources by type\r\n    const sourceGroups = this.groupSourcesByType(sources);\r\n    \r\n    // Merge within each group first\r\n    const mergedGroups: Record<string, any> = {};\r\n    \r\n    for (const [type, typeSources] of Object.entries(sourceGroups)) {\r\n      if (typeSources.length > 0) {\r\n        mergedGroups[type] = this.mergeSourcesInOrder(typeSources);\r\n      }\r\n    }\r\n\r\n    // Then merge across groups with balanced priority\r\n    return this.mergeGroupsWithBalancedPriority(mergedGroups);\r\n  }\r\n\r\n  /**\r\n   * Sort sources by AWS-first priority.\r\n   * @param sources - Configuration sources\r\n   * @returns Sorted sources (lowest priority first, highest priority last)\r\n   */\r\n  private sortSourcesByAwsFirstPriority(sources: ConfigurationSource[]): ConfigurationSource[] {\r\n    const priorityMap: Record<string, number> = {\r\n      'local-file': 1,\r\n      'environment': 2,\r\n      'ssm': 3,\r\n      'secrets-manager': 4\r\n    };\r\n\r\n    return [...sources].sort((a, b) => {\r\n      const priorityA = priorityMap[a.type] || 0;\r\n      const priorityB = priorityMap[b.type] || 0;\r\n      \r\n      if (priorityA !== priorityB) {\r\n        return priorityA - priorityB;\r\n      }\r\n      \r\n      // If same type, sort by explicit priority\r\n      return a.priority - b.priority;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sort sources by local-first priority.\r\n   * @param sources - Configuration sources\r\n   * @returns Sorted sources (lowest priority first, highest priority last)\r\n   */\r\n  private sortSourcesByLocalFirstPriority(sources: ConfigurationSource[]): ConfigurationSource[] {\r\n    const priorityMap: Record<string, number> = {\r\n      'secrets-manager': 1,\r\n      'ssm': 2,\r\n      'environment': 3,\r\n      'local-file': 4\r\n    };\r\n\r\n    return [...sources].sort((a, b) => {\r\n      const priorityA = priorityMap[a.type] || 0;\r\n      const priorityB = priorityMap[b.type] || 0;\r\n      \r\n      if (priorityA !== priorityB) {\r\n        return priorityA - priorityB;\r\n      }\r\n      \r\n      // If same type, sort by explicit priority\r\n      return a.priority - b.priority;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Group sources by their type.\r\n   * @param sources - Configuration sources\r\n   * @returns Sources grouped by type\r\n   */\r\n  private groupSourcesByType(sources: ConfigurationSource[]): Record<string, ConfigurationSource[]> {\r\n    const groups: Record<string, ConfigurationSource[]> = {};\r\n    \r\n    for (const source of sources) {\r\n      if (!groups[source.type]) {\r\n        groups[source.type] = [];\r\n      }\r\n      groups[source.type]?.push(source);\r\n    }\r\n\r\n    // Sort within each group by priority\r\n    for (const type in groups) {\r\n      groups[type]?.sort((a, b) => a.priority - b.priority);\r\n    }\r\n\r\n    return groups;\r\n  }\r\n\r\n  /**\r\n   * Merge sources in the given order (later sources override earlier ones).\r\n   * @param sources - Ordered configuration sources\r\n   * @returns Merged configuration\r\n   */\r\n  private mergeSourcesInOrder(sources: ConfigurationSource[]): Record<string, any> {\r\n    let merged: Record<string, any> = {};\r\n\r\n    for (const source of sources) {\r\n      this.logger.debug(`Merging source: ${source.name} (${source.type})`);\r\n      merged = this.deepMerge(merged, source.data);\r\n    }\r\n\r\n    return merged;\r\n  }\r\n\r\n  /**\r\n   * Merge groups with balanced priority for merge precedence.\r\n   * @param groups - Configuration groups by type\r\n   * @returns Merged configuration\r\n   */\r\n  private mergeGroupsWithBalancedPriority(groups: Record<string, any>): Record<string, any> {\r\n    let merged: Record<string, any> = {};\r\n\r\n    // Merge in balanced order: local-file -> environment -> ssm -> secrets-manager\r\n    const mergeOrder = ['local-file', 'environment', 'ssm', 'secrets-manager'];\r\n    \r\n    for (const type of mergeOrder) {\r\n      if (groups[type]) {\r\n        this.logger.debug(`Merging group: ${type}`);\r\n        merged = this.deepMerge(merged, groups[type]);\r\n      }\r\n    }\r\n\r\n    return merged;\r\n  }\r\n\r\n  /**\r\n   * Deep merge two configuration objects with conflict resolution.\r\n   * @param target - Target object (lower priority)\r\n   * @param source - Source object (higher priority)\r\n   * @returns Merged object\r\n   */\r\n  private deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any> {\r\n    const result = { ...target };\r\n\r\n    for (const [key, value] of Object.entries(source)) {\r\n      if (this.shouldDeepMerge(result[key], value)) {\r\n        result[key] = this.deepMerge(result[key], value);\r\n      } else {\r\n        result[key] = this.cloneValue(value);\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Determine if two values should be deep merged.\r\n   * @param target - Target value\r\n   * @param source - Source value\r\n   * @returns True if should deep merge, false otherwise\r\n   */\r\n  private shouldDeepMerge(target: any, source: any): boolean {\r\n    return target !== null &&\r\n           source !== null &&\r\n           typeof target === 'object' &&\r\n           typeof source === 'object' &&\r\n           !Array.isArray(target) &&\r\n           !Array.isArray(source);\r\n  }\r\n\r\n  /**\r\n   * Clone a value to avoid reference issues.\r\n   * @param value - Value to clone\r\n   * @returns Cloned value\r\n   */\r\n  private cloneValue(value: any): any {\r\n    if (value === null || typeof value !== 'object') {\r\n      return value;\r\n    }\r\n\r\n    if (Array.isArray(value)) {\r\n      return value.map(item => this.cloneValue(item));\r\n    }\r\n\r\n    const cloned: Record<string, any> = {};\r\n    for (const [key, val] of Object.entries(value)) {\r\n      cloned[key] = this.cloneValue(val);\r\n    }\r\n\r\n    return cloned;\r\n  }\r\n\r\n  /**\r\n   * Validate configuration sources for precedence handling.\r\n   * @param sources - Configuration sources to validate\r\n   * @returns Validation result with any issues found\r\n   */\r\n  validateSources(sources: ConfigurationSource[]): { valid: boolean; issues: string[] } {\r\n    const issues: string[] = [];\r\n\r\n    if (!Array.isArray(sources)) {\r\n      issues.push('Sources must be an array');\r\n      return { valid: false, issues };\r\n    }\r\n\r\n    for (let i = 0; i < sources.length; i++) {\r\n      const source = sources[i];\r\n      \r\n      if (!source) {\r\n        issues.push(`Source at index ${i} is null or undefined`);\r\n        continue;\r\n      }\r\n      \r\n      if (!source.name || typeof source.name !== 'string') {\r\n        issues.push(`Source at index ${i} must have a valid name`);\r\n      }\r\n\r\n      if (!source.type || !['environment', 'secrets-manager', 'ssm', 'local-file'].includes(source.type)) {\r\n        issues.push(`Source at index ${i} must have a valid type`);\r\n      }\r\n\r\n      if (typeof source.priority !== 'number') {\r\n        issues.push(`Source at index ${i} must have a numeric priority`);\r\n      }\r\n\r\n      if (!source.data || typeof source.data !== 'object') {\r\n        issues.push(`Source at index ${i} must have valid data object`);\r\n      }\r\n\r\n      if (!source.loadedAt || !(source.loadedAt instanceof Date)) {\r\n        issues.push(`Source at index ${i} must have a valid loadedAt date`);\r\n      }\r\n    }\r\n\r\n    return { valid: issues.length === 0, issues };\r\n  }\r\n\r\n  /**\r\n   * Get the effective priority for a source based on precedence rule.\r\n   * @param source - Configuration source\r\n   * @param precedenceRule - Precedence rule\r\n   * @returns Effective priority\r\n   */\r\n  getEffectivePriority(source: ConfigurationSource, precedenceRule: PrecedenceRule): number {\r\n    const basePriority = source.priority;\r\n    \r\n    switch (precedenceRule) {\r\n      case 'aws-first':\r\n        const awsFirstBonus = source.type === 'secrets-manager' ? 1000 :\r\n                             source.type === 'ssm' ? 500 : 0;\r\n        return basePriority + awsFirstBonus;\r\n        \r\n      case 'local-first':\r\n        const localFirstBonus = source.type === 'local-file' ? 1000 :\r\n                               source.type === 'environment' ? 500 : 0;\r\n        return basePriority + localFirstBonus;\r\n        \r\n      case 'merge':\r\n        // In merge mode, all sources have equal weight\r\n        return basePriority;\r\n        \r\n      default:\r\n        return basePriority;\r\n    }\r\n  }\r\n}"]}