ata-validator 1.50.0 → 1.52.0

package/lib/schema-order.js

@@ -57,17 +57,53 @@ function rankFor(rootSchema, schemaPath) {
   return rank;
 }
 
+// The documents a root's references reach beyond itself, id to schema, from
+// the validators that own the root (the `schemas` option, addSchema) or a
+// schema module's registry. Several validators of one root schema register
+// their maps into one; an id that two of them give different schemas makes the
+// root resolve nothing outside itself, as it did before any was registered.
+const _documents = new WeakMap();
+const CONFLICT = new Map();
+function registerDocuments(rootSchema, map) {
+  if (rootSchema === null || typeof rootSchema !== 'object' || !map || map.size === 0) return;
+  const had = _documents.get(rootSchema);
+  if (had === CONFLICT) return;
+  if (had === undefined) { _documents.set(rootSchema, new Map(map)); _rankCache.delete(rootSchema); return; }
+  let added = false;
+  for (const [id, doc] of map) {
+    const cur = had.get(id);
+    if (cur === undefined) { had.set(id, doc); added = true; } else if (cur !== doc) { _documents.set(rootSchema, CONFLICT); _rankCache.delete(rootSchema); return; }
+  }
+  if (added) _rankCache.delete(rootSchema);
+}
+
+function withoutEmptyFragment(uri) {
+  return uri.endsWith('#') ? uri.slice(0, -1) : uri;
+}
+
+function resolveUri(ref, base) {
+  try { return base ? new URL(ref, base).href : new URL(ref).href; } catch { return null; }
+}
+
 function computeRank(rootSchema, schemaPath) {
   const rank = [];
   let node = rootSchema;
   let start = 1;
   let hops = 0;
+  const docs = _documents.get(rootSchema);
+  // The document the walk is in and the base URI references resolve against,
+  // for following a reference into another document.
+  let doc = rootSchema;
+  // A root without an $id can still name another document by absolute URI.
+  const follow = docs !== undefined && docs !== CONFLICT;
+  let base = follow && typeof rootSchema.$id === 'string' ? resolveUri(rootSchema.$id, null) : null;
   while (start <= schemaPath.length) {
     let end = schemaPath.indexOf('/', start);
     if (end < 0) end = schemaPath.length;
     if (end === start) { start = end + 1; continue; }
     const seg = unescapePointerSegment(schemaPath.slice(start, end));
     if (node == null || typeof node !== 'object') break;
+    if (follow && node !== doc && !Array.isArray(node) && typeof node.$id === 'string' && node.$id[0] !== '#') base = resolveUri(node.$id, base);
     if (Array.isArray(node)) {
       const idx = Number(seg);
       if (!Number.isInteger(idx) || idx < 0 || idx >= node.length) break;
@@ -80,7 +116,11 @@ function computeRank(rootSchema, schemaPath) {
         // naming it. Ranking the rest inside the target, as if the target sat
         // under the `$ref` key, orders errors behind a reference by the
         // target's declaration order, as they are ordered inline.
-        const target = hops < 64 ? localTarget(rootSchema, node) : null;
+        let target = hops < 64 ? localTarget(doc, node) : null;
+        if (target === null && hops < 64 && follow) {
+          const remote = remoteTarget(docs, base, node);
+          if (remote !== null) { target = remote.node; doc = remote.doc; base = remote.base; }
+        }
         if (target === null) break;
         hops++;
         rank.push(keyIndex(node, '$ref'));
@@ -95,6 +135,28 @@ function computeRank(rootSchema, schemaPath) {
   return rank;
 }
 
+// The schema a node's `$ref` names in a registered document: { node, doc,
+// base }, or null when it names none (an anchor, an unknown document).
+function remoteTarget(docs, base, node) {
+  const ref = node.$ref;
+  if (typeof ref !== 'string' || ref.charCodeAt(0) === 35) return null;
+  const abs = resolveUri(ref, base);
+  if (abs === null) return null;
+  const hash = abs.indexOf('#');
+  const uri = hash < 0 ? abs : abs.slice(0, hash);
+  let target = docs.get(uri);
+  if (target === undefined) target = docs.get(uri + '#');
+  if (target === undefined) {
+    for (const [id, s] of docs) if (withoutEmptyFragment(resolveUri(id, null) || '') === uri) { target = s; break; }
+  }
+  if (target === null || typeof target !== 'object') return null;
+  const frag = hash < 0 ? '' : abs.slice(hash + 1);
+  if (frag === '') return { node: target, doc: target, base: uri };
+  if (frag.charCodeAt(0) !== 47) return null;
+  const t = localTarget(target, { $ref: '#' + frag });
+  return t === null ? null : { node: t, doc: target, base: uri };
+}
+
 // The schema a node's `$ref` names, when it is a pointer into this document.
 function localTarget(rootSchema, node) {
   const ref = node.$ref;
@@ -191,4 +253,4 @@ function ordinalFor(rootSchema, schemaPath) {
 const _missCache = new WeakMap();
 const MISS_CACHE_LIMIT = 4096;
 
-module.exports = { rankFor, ordinalFor, unescapePointerSegment };
+module.exports = { rankFor, ordinalFor, unescapePointerSegment, registerDocuments };

package/lib/schema-runtime-entry.js

@@ -10,8 +10,32 @@
 const { createInterpreter } = require('./interpreter');
 const { errorsOf, interpreterOptions } = require('./error-runtime-entry');
 
+// A registry is the array of schemas a build writes beside schema modules
+// whose schemas reference each other by `$id` (ata-registry.mjs). It becomes
+// one Map, id to schema, shared by every module of the build.
+const _maps = new WeakMap();
+function registryMap(registry) {
+  let map = _maps.get(registry);
+  if (map === undefined) {
+    map = new Map();
+    for (const s of registry) map.set(s.$id, s);
+    _maps.set(registry, map);
+  }
+  return map;
+}
+
+// options.registry and options.id: the module's schema is the registry entry
+// with that `$id`, and its references resolve against the registry.
 function createValidator(schema, codeOf, options) {
-  const interp = createInterpreter(schema, interpreterOptions(options));
+  const opts = interpreterOptions(options);
+  if (options && options.registry) {
+    const map = registryMap(options.registry);
+    if (schema === null || schema === undefined) schema = map.get(options.id);
+    opts.schemaMap = map;
+    opts.flat = false;
+    require('./schema-order').registerDocuments(schema, map);
+  }
+  const interp = createInterpreter(schema, opts);
   return {
     isValid: (data) => interp.isValid(data),
     errors: (data) => errorsOf(interp, schema, codeOf, data),

package/lib/validator-core.js

@@ -864,6 +864,9 @@ class Validator {
     if (this._initialized) return;
     this._ensureVocabularies();
     this._initialized = true;
+    // Errors behind a reference into a registered document are ordered as
+    // they would be inline: the ordering follows the reference there.
+    if (this._schemaMap && this._schemaMap.size > 0) require('./schema-order').registerDocuments(this._schemaObj, this._schemaMap);
 
     const schemaObj = this._schemaObj;
     const options = this._options;

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.50.0';
+module.exports = '1.52.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.50.0",
+  "version": "1.52.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -24,6 +24,7 @@
         "require": "./index.js"
       },
       "import": {
+        "module": "./index.bundle.mjs",
         "module-sync": "./index.node.mjs",
         "default": "./index.mjs"
       },
@@ -137,6 +138,7 @@
     "index.js",
     "index.mjs",
     "index.node.mjs",
+    "index.bundle.mjs",
     "index.browser.mjs",
     "index.edge.js",
     "index.edge.mjs",
@@ -172,13 +174,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.50.0",
-    "@ata-validator/native-darwin-x64": "1.50.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.50.0",
-    "@ata-validator/native-linux-arm64-musl": "1.50.0",
-    "@ata-validator/native-linux-x64-gnu": "1.50.0",
-    "@ata-validator/native-linux-x64-musl": "1.50.0",
-    "@ata-validator/native-win32-x64": "1.50.0"
+    "@ata-validator/native-darwin-arm64": "1.52.0",
+    "@ata-validator/native-darwin-x64": "1.52.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.52.0",
+    "@ata-validator/native-linux-arm64-musl": "1.52.0",
+    "@ata-validator/native-linux-x64-gnu": "1.52.0",
+    "@ata-validator/native-linux-x64-musl": "1.52.0",
+    "@ata-validator/native-win32-x64": "1.52.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"