@grexx/grexxlinter 0.2.348 → 0.2.350

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) {
@@ -14922,7 +15014,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.350" : "0.0.0-dev";
 function isNewer(latest, current) {
   const a = latest.split(".").map(Number);
   const b = current.split(".").map(Number);
@@ -15054,6 +15146,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 +15159,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 +15170,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;