versionary 0.20.2 → 0.21.0

package/dist/release/artifact-rules.js

@@ -8,6 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const toml_1 = __importDefault(require("@iarna/toml"));
 const yaml_1 = __importDefault(require("yaml"));
+const WILDCARD = Symbol("wildcard");
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20,6 +21,11 @@ function parseFieldPath(fieldPath) {
     while (index < fieldPath.length) {
         const current = fieldPath[index];
         if (current === ".") {
+            if (fieldPath[index + 1] === "*") {
+                tokens.push(WILDCARD);
+                index += 2;
+                continue;
+            }
             const keyMatch = fieldPath.slice(index + 1).match(/^[A-Za-z0-9_-]+/u);
             if (!keyMatch) {
                 throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
@@ -30,6 +36,11 @@ function parseFieldPath(fieldPath) {
         }
         if (current === "[") {
             const rest = fieldPath.slice(index + 1);
+            if (rest.startsWith("*]")) {
+                tokens.push(WILDCARD);
+                index += 3;
+                continue;
+            }
             const numberMatch = rest.match(/^(\d+)\]/u);
             if (numberMatch) {
                 tokens.push(Number(numberMatch[1]));
@@ -55,49 +66,86 @@ function parseFieldPath(fieldPath) {
     }
     return tokens;
 }
-function setVersionAtJsonPath(document, fieldPath, version) {
-    const tokens = parseFieldPath(fieldPath);
-    let cursor = document;
-    for (let index = 0; index < tokens.length - 1; index += 1) {
-        const token = tokens[index];
-        if (token === undefined) {
+function assignLeaf(container, key, fieldPath, version) {
+    if (typeof key === "number") {
+        if (!Array.isArray(container) || key >= container.length) {
             throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
         }
-        if (typeof token === "number") {
-            if (!Array.isArray(cursor) || token >= cursor.length) {
-                throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-            }
-            cursor = cursor[token];
-            continue;
-        }
-        if (!isRecord(cursor) || !(token in cursor)) {
-            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-        }
-        cursor = cursor[token];
-    }
-    const leaf = tokens.at(-1);
-    if (leaf === undefined) {
-        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-    }
-    if (typeof leaf === "number") {
-        if (!Array.isArray(cursor) || leaf >= cursor.length) {
-            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-        }
-        const current = cursor[leaf];
+        const current = container[key];
         if (typeof current !== "string" && typeof current !== "number") {
             throw new Error(`field-path "${fieldPath}" must point to a string or number field for version updates.`);
         }
-        cursor[leaf] = version;
+        container[key] = version;
         return;
     }
-    if (!isRecord(cursor) || !(leaf in cursor)) {
+    if (!isRecord(container) || !(key in container)) {
         throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
     }
-    const current = cursor[leaf];
+    const current = container[key];
     if (typeof current !== "string" && typeof current !== "number") {
         throw new Error(`field-path "${fieldPath}" must point to a string or number field for version updates.`);
     }
-    cursor[leaf] = version;
+    container[key] = version;
+}
+function applyTokens(cursor, tokens, position, fieldPath, version) {
+    const token = tokens[position];
+    const isLeaf = position === tokens.length - 1;
+    if (token === WILDCARD) {
+        let matched = false;
+        if (isRecord(cursor)) {
+            for (const key of Object.keys(cursor)) {
+                if (isLeaf) {
+                    assignLeaf(cursor, key, fieldPath, version);
+                    matched = true;
+                }
+                else if (applyTokens(cursor[key], tokens, position + 1, fieldPath, version)) {
+                    matched = true;
+                }
+            }
+            return matched;
+        }
+        if (Array.isArray(cursor)) {
+            for (let i = 0; i < cursor.length; i += 1) {
+                if (isLeaf) {
+                    assignLeaf(cursor, i, fieldPath, version);
+                    matched = true;
+                }
+                else if (applyTokens(cursor[i], tokens, position + 1, fieldPath, version)) {
+                    matched = true;
+                }
+            }
+            return matched;
+        }
+        throw new Error(`field-path "${fieldPath}" wildcard segment does not target an object or array.`);
+    }
+    if (typeof token === "number") {
+        if (!Array.isArray(cursor) || token >= cursor.length) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
+        if (isLeaf) {
+            assignLeaf(cursor, token, fieldPath, version);
+            return true;
+        }
+        return applyTokens(cursor[token], tokens, position + 1, fieldPath, version);
+    }
+    if (typeof token === "string") {
+        if (!isRecord(cursor) || !(token in cursor)) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
+        if (isLeaf) {
+            assignLeaf(cursor, token, fieldPath, version);
+            return true;
+        }
+        return applyTokens(cursor[token], tokens, position + 1, fieldPath, version);
+    }
+    throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+}
+function setVersionAtJsonPath(document, fieldPath, version) {
+    const tokens = parseFieldPath(fieldPath);
+    const matched = applyTokens(document, tokens, 0, fieldPath, version);
+    if (!matched) {
+        throw new Error(`field-path "${fieldPath}" did not match any fields.`);
+    }
 }
 function resolveFieldPath(rule) {
     const fieldPath = rule["field-path"] ?? rule.jsonpath;
@@ -232,6 +280,9 @@ function findMatchingBrace(content, openBraceIndex, endExclusive) {
 }
 function resolveNixPathTokens(fieldPath) {
     const tokens = parseFieldPath(fieldPath);
+    if (tokens.some((token) => token === WILDCARD)) {
+        throw new Error(`Nix artifact rules do not support wildcard segments in field-path "${fieldPath}".`);
+    }
     if (tokens.some((token) => typeof token === "number")) {
         throw new Error(`Nix artifact rules do not support array index segments in field-path "${fieldPath}".`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.20.2",
+  "version": "0.21.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",