@grexx/grexxlinter 0.2.348 → 0.2.351

package/cli.js

@@ -14456,7 +14456,7 @@ var require__ = __commonJS({
 });
 
 // src/cli.ts
-var import_yaml2 = __toESM(require_dist(), 1);
+var import_yaml3 = __toESM(require_dist(), 1);
 import { readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import { availableParallelism } from "node:os";
 import { extname, join as join2, relative } from "node:path";
@@ -14464,6 +14464,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
 
 // src/node.ts
+var import_yaml = __toESM(require_dist(), 1);
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
@@ -14569,47 +14570,6 @@ function createSchemaRegistry(schemas) {
   };
 }
 
-// src/node.ts
-var require2 = createRequire(import.meta.url);
-function resolveSchemasDir(override) {
-  if (override) return resolve(override);
-  if (process.env.SCHEMAS_DIR) return resolve(process.env.SCHEMAS_DIR);
-  const bundled = resolve(dirname(fileURLToPath(import.meta.url)), "schemas");
-  if (existsSync(bundled)) return bundled;
-  const ref = require2.resolve("@studio/schemas/extended/casetype.schema.json");
-  return dirname(ref);
-}
-function loadSchemasFromDir(dir) {
-  const out = [];
-  const walk = (d) => {
-    for (const entry of readdirSync(d, { withFileTypes: true })) {
-      const p = join(d, entry.name);
-      if (entry.isDirectory()) walk(p);
-      else if (entry.name.endsWith(".schema.json")) out.push(JSON.parse(readFileSync(p, "utf8")));
-    }
-  };
-  walk(dir);
-  return out;
-}
-function loadCoverage(dir) {
-  const file = join(dir, ".coverage.json");
-  if (!existsSync(file) || !statSync(file).isFile()) return null;
-  try {
-    return buildCoverageIndex(JSON.parse(readFileSync(file, "utf8")));
-  } catch {
-    return null;
-  }
-}
-function createNodeContext(opts = {}) {
-  const schemasDir = resolveSchemasDir(opts.schemasDir);
-  const registry = createSchemaRegistry(loadSchemasFromDir(schemasDir));
-  const coverage = loadCoverage(schemasDir);
-  return { registry, coverage, schemasDir };
-}
-
-// src/yaml.ts
-var import_yaml = __toESM(require_dist(), 1);
-
 // src/types.ts
 var DEFAULT_RULE_SEVERITY = {
   "required-field": "error",
@@ -14619,6 +14579,7 @@ var DEFAULT_RULE_SEVERITY = {
   "value-case": "warning",
   "invalid-type": "error",
   "invalid-format": "error",
+  "invalid-reference": "error",
   "unknown-casetype": "warning",
   "parse-error": "error",
   schema: "error"
@@ -14640,6 +14601,7 @@ var LINT_RULE_DESCRIPTORS = [
   { id: "value-case", label: "Value case mismatch", description: "Value matches an allowed option except for case / camelCase / separators (e.g. FORM vs form).", defaultSeverity: "warning" },
   { id: "invalid-type", label: "Invalid type", description: "Value has the wrong JSON type.", defaultSeverity: "error" },
   { id: "invalid-format", label: "Invalid format", description: "Value fails a pattern / format constraint.", defaultSeverity: "error" },
+  { id: "invalid-reference", label: "Invalid reference", description: "A case-reference field points at a file whose `_type` is not in the field's allowedCasetypes.", defaultSeverity: "error" },
   { id: "unknown-casetype", label: "Unknown casetype", description: "No schema found for the document `_type`.", defaultSeverity: "warning" },
   { id: "parse-error", label: "Parse error", description: "The YAML document could not be parsed.", defaultSeverity: "error" },
   { id: "schema", label: "Other schema error", description: "Any other constraint reported by the validator.", defaultSeverity: "error" }
@@ -14655,6 +14617,136 @@ function severityFor(rule, settings) {
   return settings.rules[rule] ?? DEFAULT_RULE_SEVERITY[rule];
 }
 
+// src/node.ts
+var require2 = createRequire(import.meta.url);
+function resolveSchemasDir(override) {
+  if (override) return resolve(override);
+  if (process.env.SCHEMAS_DIR) return resolve(process.env.SCHEMAS_DIR);
+  const bundled = resolve(dirname(fileURLToPath(import.meta.url)), "schemas");
+  if (existsSync(bundled)) return bundled;
+  const ref = require2.resolve("@studio/schemas/extended/casetype.schema.json");
+  return dirname(ref);
+}
+function loadSchemasFromDir(dir) {
+  const out = [];
+  const walk = (d) => {
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      const p = join(d, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else if (entry.name.endsWith(".schema.json")) out.push(JSON.parse(readFileSync(p, "utf8")));
+    }
+  };
+  walk(dir);
+  return out;
+}
+function loadCoverage(dir) {
+  const file = join(dir, ".coverage.json");
+  if (!existsSync(file) || !statSync(file).isFile()) return null;
+  try {
+    return buildCoverageIndex(JSON.parse(readFileSync(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function loadCaseRefs(dir) {
+  const file = join(dir, ".caserefs.json");
+  if (!existsSync(file) || !statSync(file).isFile()) return {};
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+var docCache = /* @__PURE__ */ new Map();
+function targetDoc(absPath) {
+  if (docCache.has(absPath)) return docCache.get(absPath);
+  let doc = null;
+  if (existsSync(absPath) && statSync(absPath).isFile()) {
+    try {
+      doc = (0, import_yaml.parse)(readFileSync(absPath, "utf8"));
+    } catch {
+      doc = null;
+    }
+  }
+  docCache.set(absPath, doc);
+  return doc;
+}
+function targetType(absPath, fragment) {
+  const doc = targetDoc(absPath);
+  if (doc == null || typeof doc !== "object") return "not-found";
+  if (!fragment) {
+    const t2 = doc._type;
+    return typeof t2 === "string" ? t2 : null;
+  }
+  let found = null;
+  const walk = (n) => {
+    if (found || !n || typeof n !== "object") return;
+    if (Array.isArray(n)) {
+      n.forEach(walk);
+      return;
+    }
+    const o = n;
+    if (o._uid === fragment) {
+      found = o;
+      return;
+    }
+    for (const v of Object.values(o)) walk(v);
+  };
+  walk(doc);
+  if (!found) return "not-found";
+  const t = found._type;
+  return typeof t === "string" ? t : null;
+}
+var looksLikePath = (s) => s.includes("/") || s.endsWith(".yaml") || s.endsWith(".yml");
+function referenceFindings(value, file, caseRefs, settings) {
+  const sev = severityFor("invalid-reference", settings);
+  if (sev === "off" || Object.keys(caseRefs).length === 0) return [];
+  const baseDir = dirname(file);
+  const out = [];
+  const checkRef = (ref, allowed, casetype, field, path) => {
+    if (!looksLikePath(ref)) return;
+    const frag = /^(.*\.ya?ml)#(.+)$/.exec(ref);
+    const pathPart = frag ? frag[1] : ref;
+    const fragment = frag ? frag[2] : "";
+    const t = targetType(resolve(baseDir, pathPart), fragment);
+    if (t === "not-found") {
+      out.push({ severity: sev, rule: "invalid-reference", casetype, path, field, message: `reference target not found: "${ref}"`, file });
+    } else if (t !== null && !allowed.includes(t)) {
+      out.push({ severity: sev, rule: "invalid-reference", casetype, path, field, message: `field "${field}" references a "${t}" but must reference one of: ${allowed.join(", ")}`, file });
+    }
+  };
+  const walk = (node, path) => {
+    if (Array.isArray(node)) {
+      node.forEach((n, i) => walk(n, `${path}/${i}`));
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const o = node;
+    const refs = typeof o._type === "string" ? caseRefs[o._type] : void 0;
+    if (refs) {
+      for (const [field, allowed] of Object.entries(refs)) {
+        const v = o[field];
+        if (typeof v === "string") checkRef(v, allowed, o._type, field, `${path}/${field}`);
+        else if (Array.isArray(v)) v.forEach((item, i) => {
+          if (typeof item === "string") checkRef(item, allowed, o._type, field, `${path}/${field}/${i}`);
+        });
+      }
+    }
+    for (const [k, v] of Object.entries(o)) walk(v, `${path}/${k}`);
+  };
+  walk(value, "");
+  return out;
+}
+function createNodeContext(opts = {}) {
+  const schemasDir = resolveSchemasDir(opts.schemasDir);
+  const registry = createSchemaRegistry(loadSchemasFromDir(schemasDir));
+  const coverage = loadCoverage(schemasDir);
+  return { registry, coverage, schemasDir };
+}
+
+// src/yaml.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+
 // src/lint.ts
 function ruleForKeyword(keyword) {
   switch (keyword) {
@@ -14859,8 +14951,32 @@ function lintDocument(ctx, input) {
     const schema = validate.schema;
     const forbidden = /* @__PURE__ */ new Set();
     for (const e of errors) if (e.keyword === "false schema") forbidden.add(e.instancePath);
+    const anyOfRe = /^(.*\/anyOf)\/\d+\/required$/;
+    const reqAnyGroups = /* @__PURE__ */ new Map();
+    for (const e of errors) {
+      const m = e.keyword === "required" ? anyOfRe.exec(e.schemaPath) : null;
+      if (!m) continue;
+      const key2 = `${m[1]}@${e.instancePath}`;
+      const g = reqAnyGroups.get(key2) ?? { instancePath: e.instancePath, fields: [], err: e };
+      g.fields.push(String(e.params.missingProperty));
+      reqAnyGroups.set(key2, g);
+    }
+    const emittedReqAny = /* @__PURE__ */ new Set();
     for (const e of errors) {
       if (META_KEYWORDS.has(e.keyword)) continue;
+      if (e.keyword === "required") {
+        const m = anyOfRe.exec(e.schemaPath);
+        const key2 = m ? `${m[1]}@${e.instancePath}` : null;
+        const g = key2 ? reqAnyGroups.get(key2) : null;
+        if (g && g.fields.length >= 2) {
+          if (!emittedReqAny.has(key2)) {
+            emittedReqAny.add(key2);
+            const state = describeState(schema, g.err, input.value, ctx.registry.resolveRef);
+            push("required-field", g.instancePath, null, `missing at least one of: ${g.fields.join(", ")}${state ? ` ${state}` : ""}`);
+          }
+          continue;
+        }
+      }
       const { field, path } = locate(e);
       if ((e.keyword === "additionalProperties" || e.keyword === "unevaluatedProperties") && forbidden.has(path)) {
         continue;
@@ -14874,6 +14990,18 @@ function lintDocument(ctx, input) {
           push("value-case", path, field, `"${String(actual)}" should be "${want}" (case/format mismatch)`);
           continue;
         }
+        const got = actual === void 0 ? "absent" : JSON.stringify(actual);
+        push("invalid-value", path, field, `got ${got} \u2014 ${humanize(e)}`);
+        continue;
+      }
+      if (e.keyword === "type") {
+        const actual = valueAtPointer(input.value, e.instancePath);
+        const recv = actual === null ? "null" : Array.isArray(actual) ? "array" : typeof actual;
+        let val = JSON.stringify(actual) ?? "";
+        if (val.length > 60) val = `${val.slice(0, 57)}\u2026"`;
+        const expected = String(e.params.type);
+        push("invalid-type", path, field, `expected ${expected} but received ${recv}${actual === void 0 ? "" : ` with value ${val}`}`);
+        continue;
       }
       const rule = ruleForKeyword(e.keyword);
       let message = humanize(e);
@@ -14922,7 +15050,7 @@ function isLintableYaml(text) {
 // src/cli.ts
 var PARALLEL_THRESHOLD = 200;
 var MAX_WORKERS = 8;
-var VERSION = true ? "0.2.348" : "0.0.0-dev";
+var VERSION = true ? "0.2.351" : "0.0.0-dev";
 function isNewer(latest, current) {
   const a = latest.split(".").map(Number);
   const b = current.split(".").map(Number);
@@ -14943,7 +15071,7 @@ function checkForUpdate(disabled) {
 }
 var VALID_RULES = new Set(LINT_RULE_DESCRIPTORS.map((d) => d.id));
 function parseArgs(argv) {
-  const args = { paths: [], off: [], format: "text", quiet: false, noUpdateCheck: false };
+  const args = { paths: [], off: [], format: "text", quiet: false, errorsOnly: false, noUpdateCheck: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--settings") args.settingsFile = argv[++i];
@@ -14958,6 +15086,7 @@ function parseArgs(argv) {
     else if (a === "--format") args.format = argv[++i];
     else if (a === "--report") args.report = argv[++i];
     else if (a === "--quiet") args.quiet = true;
+    else if (a === "--errors-only") args.errorsOnly = true;
     else if (a === "--no-update-check") args.noUpdateCheck = true;
     else if (a.startsWith("--")) throw new Error(`unknown option: ${a}`);
     else args.paths.push(a);
@@ -14996,18 +15125,19 @@ var COLORS = { error: "\x1B[31m", warning: "\x1B[33m", info: "\x1B[36m" };
 var RESET = "\x1B[0m";
 var useColor = process.stdout.isTTY;
 var paint = (s, c) => useColor ? `${c}${s}${RESET}` : s;
-function printText(results, settings, quiet) {
+function printText(results, settings, quiet, errorsOnly) {
   for (const r of results) {
     if (r.skipped) continue;
-    if (quiet && r.messages.length === 0) continue;
+    const msgs = errorsOnly ? r.messages.filter((m) => m.severity === "error") : r.messages;
+    if (quiet && msgs.length === 0) continue;
     const rel = r.file ? relative(process.cwd(), r.file) : "<input>";
     const head = `${rel}${r.casetype ? ` (${r.casetype})` : ""}`;
-    if (r.messages.length === 0) {
+    if (msgs.length === 0) {
       if (!quiet) console.log(`${paint("ok", COLORS.info)}  ${head}`);
       continue;
     }
     console.log(head);
-    for (const m of r.messages) {
+    for (const m of msgs) {
       const loc = m.path || "/";
       console.log(`  ${paint(m.severity.padEnd(7), COLORS[m.severity])} ${m.rule.padEnd(16)} ${loc}  ${m.message}`);
     }
@@ -15019,8 +15149,9 @@ function printText(results, settings, quiet) {
 ${s.files} file(s)${skipped ? `, ${skipped} skipped` : ""} \u2014 ${paint(`${s.errors} error(s)`, COLORS.error)}, ${paint(`${s.warnings} warning(s)`, COLORS.warning)}, ${s.infos} info(s) [fail-on: ${settings.failOn}]`
   );
 }
-function printReport(results, kind) {
-  const msgs = results.filter((r) => !r.skipped).flatMap((r) => r.messages);
+function printReport(results, kind, errorsOnly) {
+  let msgs = results.filter((r) => !r.skipped).flatMap((r) => r.messages);
+  if (errorsOnly) msgs = msgs.filter((m) => m.severity === "error");
   if (kind === "rules") {
     const by2 = /* @__PURE__ */ new Map();
     for (const m of msgs) {
@@ -15054,6 +15185,7 @@ function printReport(results, kind) {
 var WORKER_FILE = fileURLToPath2(import.meta.url);
 function lintFiles(files, ctx, settings) {
   const out = [];
+  const caseRefs = loadCaseRefs(ctx.schemasDir);
   const parseErr = (file, message) => ({
     file,
     casetype: null,
@@ -15066,7 +15198,7 @@ function lintFiles(files, ctx, settings) {
     if (!isLintableYaml(text)) continue;
     let docs;
     try {
-      docs = (0, import_yaml2.parseAllDocuments)(text);
+      docs = (0, import_yaml3.parseAllDocuments)(text);
     } catch (e) {
       out.push(parseErr(file, e.message));
       continue;
@@ -15077,7 +15209,13 @@ function lintFiles(files, ctx, settings) {
         continue;
       }
       const input = { value: doc.toJS(), file };
-      out.push(lintDocument({ registry: ctx.registry, coverage: ctx.coverage, settings }, input));
+      const result = lintDocument({ registry: ctx.registry, coverage: ctx.coverage, settings }, input);
+      const refs = referenceFindings(input.value, file, caseRefs, settings);
+      if (refs.length) {
+        result.messages.push(...refs);
+        if (result.ok && refs.some((m) => meetsThreshold(m.severity, settings.failOn))) result.ok = false;
+      }
+      out.push(result);
     }
   }
   return out;
@@ -15132,12 +15270,12 @@ async function main() {
     results = lintFiles(files, ctx, settings);
   }
   if (args.report) {
-    printReport(results, args.report);
+    printReport(results, args.report, args.errorsOnly);
   } else if (args.format === "json") {
     const active = results.filter((r) => !r.skipped);
     console.log(JSON.stringify({ summary: summarize(active), results }, null, 2));
   } else {
-    printText(results, settings, args.quiet);
+    printText(results, settings, args.quiet, args.errorsOnly);
   }
   const latest = await updatePromise;
   if (latest) {