@rogatio/cli 5.14.0 → 5.15.1

package/dist/node/index.js

@@ -11,6 +11,117 @@ import * as path from "node:path";
 
 // packages/schema/dist/node/index.js
 import { Ajv2020 } from "ajv/dist/2020.js";
+function skipBalancedGroup(source, start) {
+  let depth = 0;
+  let index = start;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === "(") depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+    index += 1;
+  }
+  return source.length;
+}
+function countCapturingGroups(urlRegex) {
+  let count = 0;
+  let index = 0;
+  while (index < urlRegex.length) {
+    const char = urlRegex[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === "(") {
+      if (urlRegex[index + 1] === "?") {
+        index = skipBalancedGroup(urlRegex, index);
+        continue;
+      }
+      count += 1;
+    }
+    index += 1;
+  }
+  return count;
+}
+function validateCaptureTemplate(template, urlRegex) {
+  const groups = countCapturingGroups(urlRegex);
+  const issues = [];
+  for (let index = 0; index < template.length; index += 1) {
+    if (template[index] !== "$") continue;
+    const next = template[index + 1];
+    if (next === "$") {
+      index += 1;
+      continue;
+    }
+    if (next === void 0 || next < "0" || next > "9") {
+      issues.push({
+        code: "invalid-syntax",
+        message: "Capture references must use $1 through $9; use $$ for a literal $.",
+        offset: index,
+        groups
+      });
+      continue;
+    }
+    const referenced = Number(next);
+    if (referenced === 0 || (template[index + 2] ?? "") >= "0" && (template[index + 2] ?? "") <= "9") {
+      issues.push({
+        code: "invalid-syntax",
+        message: "Capture references must use one digit: $1 through $9.",
+        offset: index,
+        referenced,
+        groups
+      });
+      continue;
+    }
+    if (referenced > groups) {
+      issues.push({
+        code: "out-of-range",
+        message: `Capture group $${referenced} is not defined by the URL pattern, which has ${groups} group${groups === 1 ? "" : "s"}.`,
+        offset: index,
+        referenced,
+        groups
+      });
+    }
+  }
+  return issues;
+}
+function substituteUrlCaptures(template, captures) {
+  let output = "";
+  for (let index = 0; index < template.length; index += 1) {
+    const char = template[index];
+    if (char !== "$") {
+      output += char;
+      continue;
+    }
+    const next = template[index + 1];
+    if (next === "$") {
+      output += "$";
+      index += 1;
+      continue;
+    }
+    if (next !== void 0 && next >= "1" && next <= "9") {
+      output += captures[Number(next) - 1] ?? "";
+      index += 1;
+      continue;
+    }
+    output += "$";
+  }
+  return output;
+}
+function matchUrlCaptures(urlRegex, url) {
+  try {
+    const match = new RegExp(urlRegex).exec(url);
+    return match === null ? null : match.slice(1);
+  } catch {
+    return null;
+  }
+}
 function hasControl(value) {
   for (let index = 0; index < value.length; index += 1) {
     const code = value.charCodeAt(index);
@@ -741,17 +852,25 @@ function semanticIssues(project) {
             params: {}
           });
         } else {
+          const destinationPath = `${rulePath}/redirect/destination`;
           for (const issue of validateRedirectDestination(
             destination,
             rule.urlRegex
           )) {
             issues.push({
-              instancePath: `${rulePath}/redirect/destination`,
+              instancePath: destinationPath,
               keyword: issue.code,
               message: issue.message,
               params: {}
             });
           }
+          issues.push(
+            ...captureValidationIssues(
+              destination,
+              rule.urlRegex,
+              destinationPath
+            )
+          );
         }
       }
       const effectiveOrigins = /* @__PURE__ */ new Set();
@@ -797,6 +916,14 @@ function semanticIssues(project) {
                 message: "query param value is required for set",
                 params: {}
               });
+            } else {
+              issues.push(
+                ...captureValidationIssues(
+                  param.value,
+                  rule.urlRegex,
+                  `${rulePath}/action/params/${p}/value`
+                )
+              );
             }
           } else if (param.value !== void 0) {
             issues.push({
@@ -821,6 +948,15 @@ function semanticIssues(project) {
             }
           });
         }
+        if ((rule.headerOperation ?? "set") !== "remove" && typeof rule.headerValue === "string") {
+          issues.push(
+            ...captureValidationIssues(
+              rule.headerValue,
+              rule.urlRegex,
+              `${rulePath}/headerValue`
+            )
+          );
+        }
       }
       if (rule.type === "response-body") {
         const action2 = rule.responseBody;
@@ -854,6 +990,14 @@ function semanticIssues(project) {
               message: "Replace body must not contain lone UTF-16 surrogates.",
               params: {}
             });
+          } else {
+            issues.push(
+              ...captureValidationIssues(
+                action2.body,
+                rule.urlRegex,
+                `${actionPath}/body`
+              )
+            );
           }
         } else if ("replacements" in action2 && Array.isArray(action2.replacements)) {
           if (action2.replacements.length === 0) {
@@ -927,6 +1071,14 @@ function semanticIssues(project) {
                 message: "Replace body must not contain lone UTF-16 surrogates.",
                 params: {}
               });
+            } else {
+              issues.push(
+                ...captureValidationIssues(
+                  action2.body,
+                  rule.urlRegex,
+                  `${actionPath}/body`
+                )
+              );
             }
           }
           if (action2.mode === "regex") {
@@ -1059,7 +1211,19 @@ function semanticIssues(project) {
   }
   return issues;
 }
-function skipBalancedGroup(source, start) {
+function captureValidationIssues(value, urlRegex, instancePath) {
+  return validateCaptureTemplate(value, urlRegex).map((issue) => ({
+    instancePath,
+    keyword: `schema.capture-${issue.code}`,
+    message: issue.message,
+    params: {
+      offset: issue.offset,
+      groups: issue.groups,
+      ...issue.referenced === void 0 ? {} : { referenced: issue.referenced }
+    }
+  }));
+}
+function skipBalancedGroup2(source, start) {
   let depth = 0;
   let index = start;
   const length = source.length;
@@ -1079,7 +1243,7 @@ function skipBalancedGroup(source, start) {
   }
   return length;
 }
-function countCapturingGroups(urlRegex) {
+function countCapturingGroups2(urlRegex) {
   let count = 0;
   let index = 0;
   const length = urlRegex.length;
@@ -1091,7 +1255,7 @@ function countCapturingGroups(urlRegex) {
     }
     if (char === "(") {
       if (urlRegex[index + 1] === "?") {
-        index = skipBalancedGroup(urlRegex, index);
+        index = skipBalancedGroup2(urlRegex, index);
         continue;
       }
       count += 1;
@@ -1147,7 +1311,7 @@ function validateRedirectDestination(destination, urlRegex) {
     });
     return issues;
   }
-  const groups = countCapturingGroups(urlRegex);
+  const groups = countCapturingGroups2(urlRegex);
   const backreference = /\\([1-9])/g;
   let match = backreference.exec(destination);
   while (match !== null) {
@@ -20717,6 +20881,7 @@ function authorizeExact(preset, value) {
         kind: grant.kind,
         target: grant.target,
         method: grant.method,
+        urlRegex: matcher.matcher.urlRegex.source,
         presetDigest: preset.digest
       })
     };
@@ -23383,14 +23548,14 @@ function normalizeOptions(raw) {
     }
     maxCases = maxCasesProperty.value;
   }
-  let previewAction;
+  let previewAction2;
   if (previewProperty.present) {
     if (previewProperty.value !== void 0 && typeof previewProperty.value !== "function") {
       return { ok: false };
     }
-    previewAction = previewProperty.value;
+    previewAction2 = previewProperty.value;
   }
-  return { ok: true, maxCases, previewAction };
+  return { ok: true, maxCases, previewAction: previewAction2 };
 }
 function dryRunProject(operations, cases, options) {
   const normalizedOptions = normalizeOptions(options);
@@ -25182,17 +25347,44 @@ function usageError(message) {
   return `Error: ${message}
 `;
 }
-function toMatcherOperations3(operations) {
-  return operations.map(
-    ({ groupId, ruleId, name, matcher, redactSensitiveInLogs }) => ({
-      kind: "matcher",
-      groupId,
-      ruleId,
-      name,
-      matcher,
-      redactSensitiveInLogs
-    })
-  );
+function previewAction(operation, url) {
+  const captures = matchUrlCaptures(operation.matcher.urlRegex.source, url);
+  if (captures === null) return null;
+  const expand = (value) => substituteUrlCaptures(value, captures);
+  if (operation.kind === "redirect") {
+    return {
+      kind: "redirect",
+      summary: expand(operation.redirect.destination)
+    };
+  }
+  if (operation.kind === "query") {
+    const values = operation.action.params.map(
+      (param) => param.operation === "remove" ? `${param.name}=<removed>` : `${param.name}=${expand(param.value ?? "")}`
+    ).join(", ");
+    return { kind: "query", summary: values };
+  }
+  if (operation.kind === "header") {
+    if (operation.header.operation === "remove") {
+      return { kind: "header", summary: `${operation.header.name}=<removed>` };
+    }
+    return {
+      kind: "header",
+      summary: `${operation.header.name}=${expand(operation.header.value ?? "")}`
+    };
+  }
+  if (operation.kind === "request-body" && operation.requestBody.mode === "replace") {
+    return {
+      kind: operation.kind,
+      summary: expand(operation.requestBody.body)
+    };
+  }
+  if (operation.kind === "response-body" && "mode" in operation.responseBody && operation.responseBody.mode === "replace") {
+    return {
+      kind: operation.kind,
+      summary: expand(operation.responseBody.body)
+    };
+  }
+  return null;
 }
 function isUrl(value) {
   return parseTestUrl(value).ok;
@@ -25248,7 +25440,7 @@ function addDefaults(cases, defaultMethod, defaultResourceType) {
   );
 }
 function resultOptions(maxCases) {
-  const options = {};
+  const options = { previewAction };
   if (maxCases !== void 0) options.maxCases = maxCases;
   return options;
 }
@@ -25444,7 +25636,7 @@ async function testCommandImpl(args, stdinInput, captureOutput, options = {}) {
     defaultResourceType
   );
   const dryRunResult = dryRunProject(
-    toMatcherOperations3(compileResult.operations),
+    compileResult.operations,
     testCases,
     resultOptions(maxCases)
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogatio/cli",
-  "version": "5.14.0",
+  "version": "5.15.1",
   "private": false,
   "type": "module",
   "description": "Local-first browser request and response rules — editor host, file verification, test runner, and runtime dispatch.",