@grexx/grexxlinter 0.2.2764 → 0.2.2933

package/cli.js

@@ -15052,6 +15052,35 @@ import { createRequire } from "node:module";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/deps.ts
+var DEPS_MANIFEST_PATH = "studio.deps.yaml";
+function defaultDepMount(name) {
+  return `vendor/${name}`;
+}
+var TRAILING_SLASHES = /\/{1,256}$/;
+function depMountsOf(manifest) {
+  const deps = manifest?.dependencies;
+  if (!Array.isArray(deps)) return [];
+  const out = [];
+  for (const entry of deps) {
+    const { name, mount } = entry ?? {};
+    if (typeof name !== "string" || name === "") continue;
+    const raw = typeof mount === "string" && mount !== "" ? mount : defaultDepMount(name);
+    const normalized = raw.replace(TRAILING_SLASHES, "");
+    if (normalized === "") continue;
+    out.push({ name, mount: normalized });
+  }
+  return out;
+}
+function depOfPath(path, mounts) {
+  let best;
+  for (const m of mounts) {
+    if (!path.startsWith(`${m.mount}/`)) continue;
+    if (best === void 0 || m.mount.length > best.mount.length) best = m;
+  }
+  return best?.name;
+}
+
 // src/coverage.ts
 function condKey(c) {
   if (!c) return null;
@@ -15342,6 +15371,14 @@ function layoutRootOf(paths) {
   if (paths.length !== 1) return void 0;
   return statSync(paths[0]).isDirectory() ? paths[0] : void 0;
 }
+function readDepMounts(root) {
+  if (root === void 0) return [];
+  try {
+    return depMountsOf((0, import_yaml.parse)(readFileSync(join(root, DEPS_MANIFEST_PATH), "utf8")));
+  } catch {
+    return [];
+  }
+}
 function repoPathOf(root, file) {
   return root === void 0 ? void 0 : relative(root, file).split(sep).join("/");
 }
@@ -15659,6 +15696,23 @@ function pushUncovered(push, coverage, casetype) {
   const n = coverage.uncoveredCount(casetype);
   if (n > 0) push("unknown-casetype", "", casetype, `${n} rule clause(s) for "${casetype}" are behaviour-only and not checked by the schema`);
 }
+function isInactive(node) {
+  return !!node && typeof node === "object" && node.inactive === true;
+}
+function underInactive(root, pointer) {
+  if (isInactive(root)) return true;
+  let cur = root;
+  for (const raw of pointer.split("/").slice(1)) {
+    if (cur == null || typeof cur !== "object") return false;
+    cur = cur[raw.replaceAll("~1", "/").replaceAll("~0", "~")];
+    if (isInactive(cur)) return true;
+  }
+  return false;
+}
+function dropInactive(messages, root) {
+  if (isInactive(root)) return [];
+  return messages.filter((m) => !underInactive(root, m.path));
+}
 function dedupeMessages(messages) {
   const seen = /* @__PURE__ */ new Set();
   return messages.filter((m) => {
@@ -15690,7 +15744,7 @@ function lintDocument(ctx, input) {
     });
   }
   if (settings.reportUncovered) pushUncovered(push, ctx.coverage, casetype);
-  const deduped = dedupeMessages(messages);
+  const deduped = dropInactive(dedupeMessages(messages), input.value);
   const ok = !deduped.some((m) => meetsThreshold(m.severity, settings.failOn));
   return { file: input.file, casetype, messages: deduped, skipped: false, ok };
 }
@@ -15733,13 +15787,18 @@ function parseErrorResult(file, message, settings) {
     messages: [{ severity: "error", rule: "parse-error", casetype: null, path: "", field: null, message, file }]
   };
 }
+function tagDep(result, repoPath, mounts) {
+  const dep = repoPath === void 0 || mounts === void 0 ? void 0 : depOfPath(repoPath, mounts);
+  if (dep !== void 0) for (const m of result.messages) m.dep = dep;
+  return result;
+}
 function lintOneDoc(doc, file, ctx, settings, caseRefs) {
-  if (doc.errors.length > 0) return parseErrorResult(file, doc.errors[0].message, settings);
+  const repoPath = repoPathOf(ctx.root, file);
+  if (doc.errors.length > 0) return tagDep(parseErrorResult(file, doc.errors[0].message, settings), repoPath, ctx.depMounts);
   const resolved = toJSOrError(doc);
-  if (resolved.error !== void 0) return parseErrorResult(file, resolved.error, settings);
+  if (resolved.error !== void 0) return tagDep(parseErrorResult(file, resolved.error, settings), repoPath, ctx.depMounts);
   const input = { value: resolved.value, file };
   const result = lintDocument({ registry: ctx.registry, coverage: ctx.coverage, settings }, input);
-  const repoPath = repoPathOf(ctx.root, file);
   const extra = [
     ...referenceFindings(input.value, file, caseRefs, settings),
     ...repoPath === void 0 ? [] : layoutFindings(input.value, repoPath, settings).map((m) => ({ ...m, file }))
@@ -15748,7 +15807,7 @@ function lintOneDoc(doc, file, ctx, settings, caseRefs) {
     result.messages.push(...extra);
     if (result.ok && extra.some((m) => meetsThreshold(m.severity, settings.failOn))) result.ok = false;
   }
-  return result;
+  return tagDep(result, repoPath, ctx.depMounts);
 }
 function lintOneFile(file, ctx, settings, caseRefs) {
   const text = readFileSync2(file, "utf8");
@@ -15769,7 +15828,7 @@ function lintFiles(files, ctx, settings) {
 // src/cli.ts
 var PARALLEL_THRESHOLD = 200;
 var MAX_WORKERS = 8;
-var VERSION = "0.2.2764";
+var VERSION = "0.2.2933";
 function isNewer(latest, current) {
   const a = latest.split(".").map(Number);
   const b = current.split(".").map(Number);
@@ -15823,12 +15882,15 @@ var BOOL_FLAGS = /* @__PURE__ */ new Map([
   ["--errors-only", (args) => {
     args.errorsOnly = true;
   }],
+  ["--own-only", (args) => {
+    args.ownOnly = true;
+  }],
   ["--no-update-check", (args) => {
     args.noUpdateCheck = true;
   }]
 ]);
 function parseArgs(argv) {
-  const args = { paths: [], off: [], format: "text", quiet: false, errorsOnly: false, noUpdateCheck: false };
+  const args = { paths: [], off: [], format: "text", quiet: false, errorsOnly: false, ownOnly: false, noUpdateCheck: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     const withValue = VALUE_FLAGS.get(a);
@@ -15885,7 +15947,9 @@ function printResult(r, quiet, errorsOnly) {
   if (quiet && msgs.length === 0) return;
   const rel = r.file ? relative2(process.cwd(), r.file) : "<input>";
   const casetypeTag = r.casetype ? ` (${r.casetype})` : "";
-  const head = `${rel}${casetypeTag}`;
+  const dep = msgs.find((m) => m.dep)?.dep;
+  const depTag = dep ? ` [product: ${dep}]` : "";
+  const head = `${rel}${casetypeTag}${depTag}`;
   if (msgs.length === 0) {
     if (!quiet) console.log(`${paint("ok", COLORS.info)}  ${head}`);
     return;
@@ -15896,8 +15960,18 @@ function printResult(r, quiet, errorsOnly) {
     console.log(`  ${paint(m.severity.padEnd(7), COLORS[m.severity])} ${m.rule.padEnd(16)} ${loc}  ${m.message}`);
   }
 }
+function depFindingCounts(results) {
+  const by = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    for (const m of r.messages) {
+      if (m.dep) by.set(m.dep, (by.get(m.dep) ?? 0) + 1);
+    }
+  }
+  return by;
+}
 function printSummary(results, settings) {
-  const s = summarize(results.filter((r) => !r.skipped));
+  const active = results.filter((r) => !r.skipped);
+  const s = summarize(active);
   const skipped = results.filter((r) => r.skipped).length;
   const skippedNote = skipped ? `, ${skipped} skipped` : "";
   const errorsText = paint(`${s.errors} error(s)`, COLORS.error);
@@ -15906,6 +15980,11 @@ function printSummary(results, settings) {
     `
 ${s.files} file(s)${skippedNote} \u2014 ${errorsText}, ${warningsText}, ${s.infos} info(s) [fail-on: ${settings.failOn}]`
   );
+  const byDep = depFindingCounts(active);
+  if (byDep.size > 0) {
+    const total = [...byDep.values()].reduce((a, b) => a + b, 0);
+    console.log(`${total} of those are in ${byDep.size} installed marketplace product(s) \u2014 run with --own-only to drop them`);
+  }
 }
 function printText(results, settings, quiet, errorsOnly) {
   for (const r of results) printResult(r, quiet, errorsOnly);
@@ -15944,8 +16023,15 @@ function printReport(results, kind, errorsOnly) {
     console.log(`${paint(String(r.count).padStart(cw), COLORS[r.severity])}  ${r.casetype.padEnd(tw)}  ${r.severity.padEnd(8)}  ${r.message}`);
   }
 }
+function withoutDepFindings(results, settings) {
+  return results.map((r) => {
+    const messages = r.messages.filter((m) => !m.dep);
+    if (messages.length === r.messages.length) return r;
+    return { ...r, messages, ok: !messages.some((m) => meetsThreshold(m.severity, settings.failOn)) };
+  });
+}
 var WORKER_FILE = fileURLToPath2(import.meta.url);
-async function runParallel(files, settings, schemasDir, root) {
+async function runParallel(files, settings, schemasDir, root, depMounts) {
   const n = Math.min(MAX_WORKERS, availableParallelism(), files.length);
   const shards = Array.from({ length: n }, () => []);
   files.forEach((f, i) => shards[i % n].push(f));
@@ -15954,7 +16040,7 @@ async function runParallel(files, settings, schemasDir, root) {
     const parts = await Promise.all(
       shards.map(
         (shard) => new Promise((resolve2, reject) => {
-          const w = new Worker(WORKER_FILE, { workerData: { shard, settings, schemasDir, root } });
+          const w = new Worker(WORKER_FILE, { workerData: { shard, settings, schemasDir, root, depMounts } });
           w.once("message", (m) => {
             void w.terminate();
             resolve2(m);
@@ -15967,13 +16053,13 @@ async function runParallel(files, settings, schemasDir, root) {
   } catch (e) {
     if (process.env.GREXXLINT_DEBUG) console.error("[grexxlint] worker pool failed, inline fallback:", e);
     const ctx = createNodeContext({ schemasDir });
-    return lintFiles(files, { ...ctx, root }, settings);
+    return lintFiles(files, { ...ctx, root, depMounts }, settings);
   }
 }
 function runWorker() {
-  const { shard, settings, schemasDir, root } = workerData;
+  const { shard, settings, schemasDir, root, depMounts } = workerData;
   const ctx = createNodeContext({ schemasDir });
-  parentPort.postMessage(lintFiles(shard, { ...ctx, root }, settings));
+  parentPort.postMessage(lintFiles(shard, { ...ctx, root, depMounts }, settings));
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
@@ -15987,14 +16073,16 @@ async function main() {
   const settings = normalizeSettings(partial);
   const files = discover(args.paths, settings.exclude);
   const root = layoutRootOf(args.paths);
+  const depMounts = readDepMounts(root);
   const canParallel = WORKER_FILE.endsWith(".js") && files.length > PARALLEL_THRESHOLD;
   let results;
   if (canParallel) {
-    results = await runParallel(files, settings, args.schemasDir, root);
+    results = await runParallel(files, settings, args.schemasDir, root, depMounts);
   } else {
     const ctx = createNodeContext({ schemasDir: args.schemasDir });
-    results = lintFiles(files, { ...ctx, root }, settings);
+    results = lintFiles(files, { ...ctx, root, depMounts }, settings);
   }
+  if (args.ownOnly) results = withoutDepFindings(results, settings);
   if (args.report) {
     printReport(results, args.report, args.errorsOnly);
   } else if (args.format === "json") {

package/lsp.js

@@ -25608,6 +25608,23 @@ function pushUncovered(push, coverage, casetype) {
   const n = coverage.uncoveredCount(casetype);
   if (n > 0) push("unknown-casetype", "", casetype, `${n} rule clause(s) for "${casetype}" are behaviour-only and not checked by the schema`);
 }
+function isInactive(node) {
+  return !!node && typeof node === "object" && node.inactive === true;
+}
+function underInactive(root, pointer) {
+  if (isInactive(root)) return true;
+  let cur = root;
+  for (const raw of pointer.split("/").slice(1)) {
+    if (cur == null || typeof cur !== "object") return false;
+    cur = cur[raw.replaceAll("~1", "/").replaceAll("~0", "~")];
+    if (isInactive(cur)) return true;
+  }
+  return false;
+}
+function dropInactive(messages, root) {
+  if (isInactive(root)) return [];
+  return messages.filter((m) => !underInactive(root, m.path));
+}
 function dedupeMessages(messages) {
   const seen = /* @__PURE__ */ new Set();
   return messages.filter((m) => {
@@ -25639,7 +25656,7 @@ function lintDocument(ctx2, input) {
     });
   }
   if (settings2.reportUncovered) pushUncovered(push, ctx2.coverage, casetype);
-  const deduped = dedupeMessages(messages);
+  const deduped = dropInactive(dedupeMessages(messages), input.value);
   const ok = !deduped.some((m) => meetsThreshold(m.severity, settings2.failOn));
   return { file: input.file, casetype, messages: deduped, skipped: false, ok };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grexx/grexxlinter",
-  "version": "0.2.2764",
+  "version": "0.2.2933",
   "description": "Lint Grexx Studio casetype YAML against the studio JSON Schemas.",
   "type": "module",
   "bin": {

package/schemas/mapping.schema.json

@@ -240,6 +240,21 @@
         }
       }
     },
+    {
+      "$comment": "A mapping always names a destination. Which field carries it depends on toAttributeType (usersession -> toKey, everything else -> toAttribute), and the generated branches already require toKey for usersession and activityAttribute for taskAttribute -- but nothing requires the ordinary toAttribute, so a mapping with no destination at all linted clean. Zero findings across packages/schemas/def-yamls-142 and apps/backend/test/fixtures/compile-6685 (1837 active mappings).",
+      "anyOf": [
+        {
+          "required": [
+            "toAttribute"
+          ]
+        },
+        {
+          "required": [
+            "toKey"
+          ]
+        }
+      ]
+    },
     {
       "if": {
         "properties": {

package/schemas/metadata.behavior.json

@@ -121,6 +121,17 @@
   },
   "cookieConsentEnabled": {
     "baseline": "MUST_NOT",
+    "requiredWhen": [
+      {
+        "op": "cmp",
+        "field": "type",
+        "fieldName": "Type metadata",
+        "operator": "==",
+        "value": "cookieconsent",
+        "valueIsField": false,
+        "isEmpty": false
+      }
+    ],
     "enabledWhen": [
       {
         "op": "cmp",
@@ -185,6 +196,17 @@
   },
   "cookieConsentType": {
     "baseline": "MUST_NOT",
+    "requiredWhen": [
+      {
+        "op": "cmp",
+        "field": "type",
+        "fieldName": "Type metadata",
+        "operator": "==",
+        "value": "cookieconsent",
+        "valueIsField": false,
+        "isEmpty": false
+      }
+    ],
     "enabledWhen": [
       {
         "op": "cmp",

package/schemas/trigger.schema.json

@@ -120,7 +120,23 @@
   ],
   "title": "trigger",
   "type": "object",
+  "$comment": "Hand-maintained overlay (deep-merged by scripts/extend.mjs into extended/trigger.schema.json). A trigger always names an activity to run, whatever its `toTriggerType` -- see the allOf below. The manager exports this per toTriggerType value, but the `page` group's `when` is \"[To page] is not «empty» AND [To type] is \\\"page\\\"\", and condToSchema cannot express the not-empty conjunct (`!==` is outside EQ_OPS and `''` is in BAD_VALUES), so that one group is deferred and never reaches the schema. Stating it unconditionally covers `page`, and additionally covers a trigger with no `toTriggerType` at all -- which the per-value groups all miss, since each `if` requires the field to be present. Conditionals generated by packages/schemas/scripts/extend.mjs from rules/trigger.json.",
   "allOf": [
+    {
+      "$comment": "Zero findings across packages/schemas/def-yamls-142 and apps/backend/test/fixtures/compile-6685 (659 active triggers).",
+      "anyOf": [
+        {
+          "required": [
+            "activityTo"
+          ]
+        },
+        {
+          "required": [
+            "activityTag"
+          ]
+        }
+      ]
+    },
     {
       "if": {
         "properties": {
@@ -453,6 +469,5 @@
         ]
       }
     }
-  ],
-  "$comment": "Conditionals generated by packages/schemas/scripts/extend.mjs from rules/trigger.json."
+  ]
 }