helm-env-delta 1.8.0 → 1.8.1

package/README.md

@@ -780,7 +780,7 @@ git push origin main
 
 ✅ **Flexibility** - Per-file patterns. Config inheritance. Regex transforms.
 
-✅ **Reliability** - 920 tests, 84% coverage. Battle-tested.
+✅ **Reliability** - 990+ tests, 84% coverage. Battle-tested.
 
 ---
 

package/dist/fileUpdater.js

@@ -10,6 +10,7 @@ const yaml_1 = __importDefault(require("yaml"));
 const consoleFormatter_1 = require("./consoleFormatter");
 const errors_1 = require("./utils/errors");
 const fileType_1 = require("./utils/fileType");
+const jsonPath_1 = require("./utils/jsonPath");
 const transformer_1 = require("./utils/transformer");
 const yamlFormatter_1 = require("./yamlFormatter");
 const FileUpdaterErrorClass = (0, errors_1.createErrorClass)('File Updater Error', {
@@ -61,15 +62,112 @@ const ensureParentDirectory = async (filePath) => {
         });
     }
 };
-const deepMerge = (fullTarget, filteredSource, filteredTarget) => {
+const getApplicableArrayFilters = (currentPath, skipPaths) => {
+    const filters = [];
+    for (const skipPath of skipPaths) {
+        const segments = (0, jsonPath_1.parseJsonPath)(skipPath);
+        if (segments.length <= currentPath.length)
+            continue;
+        let isPrefix = true;
+        for (let index = 0; index < currentPath.length; index++)
+            if (segments[index] !== currentPath[index]) {
+                isPrefix = false;
+                break;
+            }
+        if (!isPrefix)
+            continue;
+        const nextSegment = segments[currentPath.length];
+        if (!nextSegment || !(0, jsonPath_1.isFilterSegment)(nextSegment))
+            continue;
+        const filter = (0, jsonPath_1.parseFilterSegment)(nextSegment);
+        if (!filter)
+            continue;
+        const remainingPath = segments.slice(currentPath.length + 1);
+        filters.push({ filter, remainingPath });
+    }
+    return filters;
+};
+const itemMatchesAnyFilter = (item, applicableFilters) => {
+    if (!item || typeof item !== 'object')
+        return { matches: false };
+    const itemObject = item;
+    for (const applicableFilter of applicableFilters) {
+        const itemValue = itemObject[applicableFilter.filter.property];
+        if (itemValue !== undefined && (0, jsonPath_1.matchesFilter)(itemValue, applicableFilter.filter))
+            return { matches: true, matchedFilter: applicableFilter };
+    }
+    return { matches: false };
+};
+const findMatchingTargetItem = (sourceItem, fullTargetArray, applicableFilters) => {
+    if (!sourceItem || typeof sourceItem !== 'object')
+        return undefined;
+    const sourceObject = sourceItem;
+    for (const targetItem of fullTargetArray) {
+        if (!targetItem || typeof targetItem !== 'object')
+            continue;
+        const targetObject = targetItem;
+        for (const { filter } of applicableFilters)
+            if (sourceObject[filter.property] === targetObject[filter.property])
+                return targetItem;
+    }
+    return undefined;
+};
+const shouldPreserveItem = (item, applicableFilters, existingResult) => {
+    if (!item || typeof item !== 'object')
+        return false;
+    const itemObject = item;
+    const { matches } = itemMatchesAnyFilter(item, applicableFilters);
+    if (!matches)
+        return false;
+    for (const existingItem of existingResult) {
+        if (!existingItem || typeof existingItem !== 'object')
+            continue;
+        const existingObject = existingItem;
+        let isDuplicate = true;
+        for (const { filter } of applicableFilters)
+            if (existingObject[filter.property] !== itemObject[filter.property]) {
+                isDuplicate = false;
+                break;
+            }
+        if (isDuplicate)
+            return false;
+    }
+    return true;
+};
+const deepMerge = (fullTarget, filteredSource, filteredTarget, currentPath = [], skipPaths = []) => {
     if (filteredSource === null || filteredSource === undefined)
         return fullTarget;
     if (fullTarget === null || fullTarget === undefined)
         return filteredSource;
     if (typeof fullTarget !== typeof filteredSource)
         return filteredSource;
-    if (Array.isArray(filteredSource))
-        return filteredSource;
+    if (Array.isArray(filteredSource)) {
+        const fullTargetArray = Array.isArray(fullTarget) ? fullTarget : [];
+        const filteredTargetArray = Array.isArray(filteredTarget) ? filteredTarget : [];
+        const applicableFilters = getApplicableArrayFilters(currentPath, skipPaths);
+        if (applicableFilters.length === 0)
+            return filteredSource;
+        const hasNestedFilters = applicableFilters.some((f) => f.remainingPath.length > 0);
+        const result = [];
+        for (const sourceItem of filteredSource) {
+            if (hasNestedFilters && sourceItem && typeof sourceItem === 'object') {
+                const { matches, matchedFilter } = itemMatchesAnyFilter(sourceItem, applicableFilters);
+                if (matches && matchedFilter && matchedFilter.remainingPath.length > 0) {
+                    const matchingTargetItem = findMatchingTargetItem(sourceItem, fullTargetArray, applicableFilters);
+                    const matchingFilteredTargetItem = findMatchingTargetItem(sourceItem, filteredTargetArray, applicableFilters);
+                    if (matchingTargetItem) {
+                        result.push(deepMerge(matchingTargetItem, sourceItem, matchingFilteredTargetItem, currentPath, skipPaths));
+                        continue;
+                    }
+                }
+            }
+            result.push(sourceItem);
+        }
+        for (const item of fullTargetArray)
+            if (shouldPreserveItem(item, applicableFilters, result))
+                result.push(item);
+        return result;
+    }
     if (typeof filteredSource === 'object' && typeof fullTarget === 'object') {
         const sourceObject = filteredSource;
         const fullTargetObject = fullTarget;
@@ -80,12 +178,12 @@ const deepMerge = (fullTarget, filteredSource, filteredTarget) => {
                 result[key] = value;
         for (const [key, value] of Object.entries(sourceObject))
             if (key in fullTargetObject)
-                result[key] = deepMerge(fullTargetObject[key], value, filteredTargetObject[key]);
+                result[key] = deepMerge(fullTargetObject[key], value, filteredTargetObject[key], [...currentPath, key], skipPaths);
         return result;
     }
     return filteredSource;
 };
-const mergeYamlContent = (destinationContent, processedSourceContent, filteredDestinationContent, filePath) => {
+const mergeYamlContent = (destinationContent, processedSourceContent, filteredDestinationContent, filePath, skipPaths = []) => {
     let destinationParsed;
     try {
         destinationParsed = yaml_1.default.parse(destinationContent);
@@ -104,7 +202,7 @@ const mergeYamlContent = (destinationContent, processedSourceContent, filteredDe
     }
     let merged;
     try {
-        merged = deepMerge(destinationParsed, processedSourceContent, filteredDestinationContent);
+        merged = deepMerge(destinationParsed, processedSourceContent, filteredDestinationContent, [], skipPaths);
     }
     catch (error) {
         throw new FileUpdaterError('Failed to merge YAML content', {
@@ -168,7 +266,7 @@ const updateFile = async (options) => {
         return;
     }
     let contentToWrite = (0, fileType_1.isYamlFile)(changedFile.path)
-        ? mergeYamlContent(changedFile.destinationContent, changedFile.rawParsedSource, changedFile.rawParsedDest, changedFile.path)
+        ? mergeYamlContent(changedFile.destinationContent, changedFile.rawParsedSource, changedFile.rawParsedDest, changedFile.path, changedFile.skipPaths)
         : changedFile.sourceContent;
     if ((0, fileType_1.isYamlFile)(changedFile.path)) {
         const effectiveOutputFormat = skipFormat ? undefined : config.outputFormat;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helm-env-delta",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "HelmEnvDelta – environment-aware YAML delta and sync for GitOps",
   "author": "BCsabaEngine",
   "license": "ISC",