ata-validator 1.48.0 → 1.50.0

package/lib/schema-strip.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// A copy of a schema without the keywords that only describe it (title,
+// description, examples and the like), for a compact module that embeds its
+// schema so the shared error runtime can walk it. Validation never reads
+// these, and in a typical published schema they are most of the bytes.
+//
+// Only schema positions are touched. An `enum`, a `const` or any keyword this
+// file does not know is copied as it is, so a value that happens to hold a
+// "description" key keeps it. If a local `$ref` points through a keyword that
+// would be removed, nothing is removed: the reference has to land where it
+// did.
+
+const DROP = new Set([
+  'title', 'description', '$comment', 'examples', 'default', 'deprecated',
+  'readOnly', 'writeOnly', 'markdownDescription', 'deprecationMessage',
+  'enumDescriptions', 'markdownEnumDescriptions', 'defaultSnippets',
+]);
+
+const SINGLE = new Set([
+  'additionalProperties', 'contains', 'propertyNames', 'if', 'then', 'else', 'not',
+  'items', 'unevaluatedItems', 'unevaluatedProperties', 'additionalItems', 'contentSchema',
+]);
+const MAPS = new Set(['$defs', 'definitions', 'properties', 'patternProperties', 'dependentSchemas']);
+const LISTS = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems']);
+
+function dropped(key) {
+  return DROP.has(key) || key.startsWith('x-');
+}
+
+function setOwn(o, k, v) {
+  // A key named __proto__ has to stay an own property.
+  if (k === '__proto__') Object.defineProperty(o, k, { value: v, enumerable: true, writable: true, configurable: true });
+  else o[k] = v;
+}
+
+function unescape(seg) {
+  return seg.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+// True when some local reference walks through a key that would be dropped.
+function refsIntoDropped(node, seen) {
+  if (node === null || typeof node !== 'object') return false;
+  if (seen.has(node)) return false;
+  seen.add(node);
+  if (Array.isArray(node)) {
+    for (const x of node) if (refsIntoDropped(x, seen)) return true;
+    return false;
+  }
+  for (const k of ['$ref', '$dynamicRef', '$recursiveRef']) {
+    const r = node[k];
+    if (typeof r !== 'string') continue;
+    const hash = r.indexOf('#');
+    if (hash < 0) continue;
+    let frag;
+    try { frag = decodeURIComponent(r.slice(hash + 1)); } catch { return true; }
+    if (!frag.startsWith('/')) continue;
+    for (const seg of frag.slice(1).split('/')) if (dropped(unescape(seg))) return true;
+  }
+  for (const k of Object.keys(node)) if (refsIntoDropped(node[k], seen)) return true;
+  return false;
+}
+
+// keepTitle: the node is a branch of anyOf or oneOf, whose title names the
+// branch in the collapsed error (params.closestName).
+function stripSchema(node, keepTitle) {
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) return node;
+  const out = {};
+  for (const k of Object.keys(node)) {
+    if (dropped(k) && !(keepTitle === true && k === 'title')) continue;
+    const v = node[k];
+    if (SINGLE.has(k)) {
+      setOwn(out, k, Array.isArray(v) ? v.map((x) => stripSchema(x, false)) : stripSchema(v, false));
+    } else if (MAPS.has(k) && v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      const m = {};
+      for (const name of Object.keys(v)) setOwn(m, name, stripSchema(v[name], false));
+      setOwn(out, k, m);
+    } else if (LISTS.has(k) && Array.isArray(v)) {
+      const branches = k === 'anyOf' || k === 'oneOf';
+      setOwn(out, k, v.map((x) => stripSchema(x, branches)));
+    } else if (k === 'dependencies' && v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      const m = {};
+      for (const name of Object.keys(v)) setOwn(m, name, Array.isArray(v[name]) ? v[name] : stripSchema(v[name], false));
+      setOwn(out, k, m);
+    } else if (k === 'propertyDependencies' && v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      const m = {};
+      for (const name of Object.keys(v)) {
+        const inner = v[name];
+        if (inner === null || typeof inner !== 'object' || Array.isArray(inner)) { setOwn(m, name, inner); continue; }
+        const mi = {};
+        for (const val of Object.keys(inner)) setOwn(mi, val, stripSchema(inner[val], false));
+        setOwn(m, name, mi);
+      }
+      setOwn(out, k, m);
+    } else {
+      setOwn(out, k, v);
+    }
+  }
+  return out;
+}
+
+// A compact or schema module strips its schema three times on the way out
+// (the reference check, the module, the flat-index check): once per schema
+// object. A validator's schema object does not change after it compiles.
+const _stripped = new WeakMap();
+function stripAnnotations(schema) {
+  if (schema === null || typeof schema !== 'object') return schema;
+  const hit = _stripped.get(schema);
+  if (hit !== undefined) return hit;
+  const out = refsIntoDropped(schema, new Set()) ? schema : stripSchema(schema, false);
+  _stripped.set(schema, out);
+  return out;
+}
+
+module.exports = { stripAnnotations };

package/lib/tools.mjs

@@ -0,0 +1,21 @@
+// The package's tools as ES modules, one import each, for the entries a
+// bundler reads (index.browser.mjs, index.edge.mjs): an application that
+// imports only Validator leaves TypeScript generation, the renderers, the
+// output format, the retry message and the schema description out of its
+// bundle. Through index.js they load on first call instead, which a bundler
+// cannot see, so it kept all of them.
+import tsGen from './ts-gen.js';
+import renderPrettyMod from './render-pretty.js';
+import renderCompactMod from './render-compact.js';
+import outputFormat from './output-format.js';
+import retryMessage from './retry-message.js';
+import describe from './describe-schema.js';
+import renderJsonMod from './render-json.js';
+
+export function toTypeScript (...a) { return tsGen.toTypeScript(...a); }
+export function renderPretty (...a) { return renderPrettyMod.renderPretty(...a); }
+export function renderCompact (...a) { return renderCompactMod.renderCompact(...a); }
+export function toOutput (...a) { return outputFormat.toOutput(...a); }
+export function toRetryMessage (...a) { return retryMessage.toRetryMessage(...a); }
+export function describeSchema (...a) { return describe.describeSchema(...a); }
+export function renderJSON (...a) { return renderJsonMod.renderJSON(...a); }

package/lib/validator-core.js

@@ -25,7 +25,15 @@ function _registerCodegen(engine) {
   _codegen = engine;
   ({ compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined } = engine.jsCompiler);
 }
-const { normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions } = require("./draft7");
+// The ahead-of-time loaders without the code generator: the edge entry
+// (index.edge.js) registers lib/aot.browser.js here, so modules written by
+// `ata build` or Validator.bundle() load where generated code cannot run.
+// The emitters stay out, as they do in a browser bundle of the full package.
+let _aotLoader = null;
+function _registerAot(load) {
+  _aotLoader = load;
+}
+const { draftCode, normalizeDraft2019, normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions } = require("./draft7");
 const { enabledKeywords, stripDisabledKeywords } = require("./vocabularies");
 const { needsNormalization } = require("./schema-scan");
 const { isV1Dialect } = require("./dialect");
@@ -426,21 +434,26 @@ function _deepCloneWithSymbols(v) {
 // Normalize a caller-provided schema without mutating the original.
 // Clones only when normalization would change the object (draft-07 keys
 // present or nullable fields present). Internal-only — not exported.
+// `inheritDraft7` is the root's draft for a document that declares none of
+// its own: 0 or absent for none, 1 for draft-07, 2 for draft-06, 3 for 2019-09.
 function _normalizeCallerSchema(s, inheritDraft7) {
-  const declares = s && typeof s === 'object' && s.$schema !== undefined
-  const needsDraft7 = declares
-    ? (s.$schema === 'http://json-schema.org/draft-07/schema#' || s.$schema === 'http://json-schema.org/draft-07/schema')
-    : !!inheritDraft7
+  const declared = s && typeof s === 'object' ? s.$schema : undefined
+  const code = declared !== undefined ? draftCode(declared) : (inheritDraft7 || 0)
+  const needsDraft7 = code === 1 || code === 2
+  const draft6 = code === 2
+  const draft2019 = code === 3
   // One walk answers whether there is anything to do. Almost always there is
   // not, and then the serialize, clone, normalize, serialize, compare below is
   // work spent to find that out. The walk over-reports rather than under, so a
   // schema it clears is one no normalizer would have touched;
   // `tests/test_schema_scan.js` holds that direction against the whole suite.
-  if (!needsNormalization(s, needsDraft7)) return s
+  // The scan does not look for `if`/`then`/`else`, which draft-06 drops.
+  if (!draft6 && !draft2019 && !needsNormalization(s, needsDraft7)) return s
 
   const str = JSON.stringify(s)
   const copy = _deepCloneWithSymbols(s)
-  if (needsDraft7) normalizeDraft7(copy, true)
+  if (needsDraft7) normalizeDraft7(copy, true, draft6)
+  if (draft2019) normalizeDraft2019(copy, true)
   normalizeNullable(copy)
   normalizeExclusiveBounds(copy)
   // Return original when normalization produced no change, copy otherwise.
@@ -467,7 +480,7 @@ function declaredId(original, normalized) {
   return undefined
 }
 
-// `inheritDraft7` is true when the root schema is draft-07: a retrieved
+// `inheritDraft7` is non-zero when the root schema is draft-07 or draft-06: a retrieved
 // document that declares no dialect is read under the root's draft.
 // The map is derived entirely from what the caller passed, so the same
 // `schemas` gives the same map. A server building one validator per route over
@@ -485,12 +498,12 @@ function buildSchemaMap(schemas, inheritDraft7) {
   if (!schemas) return null
   const byDraft = _schemaMapCache.get(schemas)
   if (byDraft) {
-    const hit = byDraft[inheritDraft7 ? 1 : 0]
+    const hit = byDraft[inheritDraft7 || 0]
     if (hit) return hit
   }
   const map = _buildSchemaMap(schemas, inheritDraft7)
-  const slot = byDraft || [null, null]
-  slot[inheritDraft7 ? 1 : 0] = map
+  const slot = byDraft || [null, null, null, null]
+  slot[inheritDraft7 || 0] = map
   if (!byDraft) _schemaMapCache.set(schemas, slot)
   return map
 }
@@ -676,8 +689,7 @@ class Validator {
     // uses, and a benchmark timing construction measures construction.
     // When schema is a string, JSON.parse already produces a fresh object.
     const raw = typeof schema === "string" ? JSON.parse(schema) : schema;
-    const rootIsDraft7 = !!(raw && typeof raw === 'object' && typeof raw.$schema === 'string' &&
-      (raw.$schema === 'http://json-schema.org/draft-07/schema#' || raw.$schema === 'http://json-schema.org/draft-07/schema'));
+    const rootIsDraft7 = raw && typeof raw === 'object' ? draftCode(raw.$schema) : 0;
 
     // Built here rather than below because `$vocabulary` is resolved against
     // it, and that resolution waits until compilation so a meta-schema
@@ -1561,8 +1573,7 @@ class Validator {
     // Normalize a copy so the caller's object is never mutated. A document
     // without a dialect of its own is read under the root's draft.
     const root = this._schemaObj
-    const rootIsDraft7 = !!(root && typeof root === 'object' && typeof root.$schema === 'string' &&
-      (root.$schema === 'http://json-schema.org/draft-07/schema#' || root.$schema === 'http://json-schema.org/draft-07/schema'))
+    const rootIsDraft7 = root && typeof root === 'object' ? draftCode(root.$schema) : 0
     const normalized = _normalizeCallerSchema(schema, rootIsDraft7)
     this._ownSchemaMap()
     this._schemaMap.set(normalized.$id, normalized)
@@ -1596,7 +1607,7 @@ class Validator {
   static fromStandalone(mod, schema, opts) {
     // It loads what Validator.bundleStandalone() writes, and compiles an error
     // function when the module carries none, so it goes with those methods.
-    if (_codegen === null) throw new TypeError('Validator.fromStandalone is not part of ata-validator/lite, like the bundle methods it loads for. Import it from ata-validator, or import a module from `ata build` directly.');
+    if (_codegen === null && _aotLoader === null) throw new TypeError('Validator.fromStandalone is not part of ata-validator/lite, like the bundle methods it loads for. Import it from ata-validator, or import a module from `ata build` directly.');
     const options = opts || {};
     const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
 
@@ -1632,7 +1643,9 @@ class Validator {
     });
     if (mod.errFn) {
       errFn = (d) => mod.errFn(d, true);
-    } else {
+    } else if (compileToJSCodegenWithErrors !== undefined) {
+      // Without the code generator (the edge entry) a module that carries no
+      // error function reports the stub above.
       const jsErrFn = compileToJSCodegenWithErrors(schemaObj);
       if (jsErrFn) {
         try {
@@ -1780,8 +1793,9 @@ function version() {
 // generated module shapes; browser bundles get `lib/aot.browser.js` (a stub
 // that throws) via the package.json `browser` field.
 function _aot() {
-  if (_codegen === null) throw new TypeError('The ahead-of-time bundle methods are not part of ata-validator/lite. Import them from ata-validator.');
-  return _codegen.aot();
+  if (_codegen !== null) return _codegen.aot();
+  if (_aotLoader !== null) return _aotLoader();
+  throw new TypeError('The ahead-of-time bundle methods are not part of ata-validator/lite. Import them from ata-validator.');
 }
 Validator.bundle = function (schemas, opts) {
   return _aot().bundle(Validator, schemas, opts);
@@ -2192,7 +2206,7 @@ function _buildParse(self) {
   // isValidObject, which runs them, and a property they check with instanceof
   // is carried over as it is (see clone-emit).
   const extended = self._verdictTail !== null || self._validateTail !== null;
-  if (_codegen === null) return decline('ata-validator/lite has no code generator to build the copy with', 'Use parse() from ata-validator, or validate(); a valid result carries the input as it is.');
+  if (_codegen === null) return decline('this entry has no code generator to build the copy with', 'Use validate(); a valid result carries the input as it is.');
   return _codegen.buildParse(self, decline, extended);
 }
 
@@ -2366,5 +2380,6 @@ module.exports = {
 // How an entry registers the code generator. Not enumerable, so the exported
 // surface of `require('ata-validator')` is what it was.
 Object.defineProperty(module.exports, '_registerCodegen', { value: _registerCodegen, enumerable: false });
+Object.defineProperty(module.exports, '_registerAot', { value: _registerAot, enumerable: false });
 // What the compiled paths in index.js need from this module.
 Object.defineProperty(module.exports, '_internals', { value: { _jsonSyntaxRejection, ABORT_EARLY_RESULT, HYBRID_TIER_CALLS, SIMDJSON_THRESHOLD, VALID_RESULT, _bindEntry, _bindVerdict, _compileCache, _compileCacheSet, _mustReject, _rememberInstance, _verboseWrap, compileCacheKey, getNative, isV1Dialect, resolveSchemaByPath }, enumerable: false });

package/lib/version.js

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

package/lib/vocabularies.js

@@ -50,6 +50,18 @@ function keywordsByVocabulary() {
       new Set(Object.keys(meta.properties)),
     )
   }
+  // Draft 2019-09's vocabularies, from its own vendored meta-schemas. A
+  // 2019-09 dialect names these URIs in `$vocabulary`.
+  for (const name of ['core', 'applicator', 'validation', 'meta-data', 'format', 'content']) {
+    const meta = require('./metaschemas').METASCHEMAS.get(
+      `https://json-schema.org/draft/2019-09/meta/${name}`,
+    )
+    if (!meta || !meta.properties) continue
+    byVocabulary.set(
+      `https://json-schema.org/draft/2019-09/vocab/${name}`,
+      new Set(Object.keys(meta.properties)),
+    )
+  }
   // The one vocabulary with no document to read. `format-assertion` is an
   // alternative to `format-annotation` rather than part of the standard
   // dialect, so its meta-schema is not among the vendored ones. It defines

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.48.0",
+  "version": "1.50.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",
@@ -8,6 +8,16 @@
   "types": "index.d.ts",
   "exports": {
     ".": {
+      "workerd": {
+        "types": "./index.d.ts",
+        "import": "./index.edge.mjs",
+        "require": "./index.edge.js"
+      },
+      "edge-light": {
+        "types": "./index.d.ts",
+        "import": "./index.edge.mjs",
+        "require": "./index.edge.js"
+      },
       "types": "./index.d.ts",
       "browser": {
         "import": "./index.browser.mjs",
@@ -54,6 +64,11 @@
       "import": "./lite.mjs",
       "require": "./lite.js"
     },
+    "./error-runtime": {
+      "types": "./error-runtime.d.ts",
+      "import": "./error-runtime.mjs",
+      "require": "./error-runtime.js"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -72,7 +87,7 @@
     "rebuild": "cmake-js rebuild --target ata",
     "test": "node tests/run.js",
     "bench:size": "node benchmark/bench_aot_size.mjs",
-    "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1",
+    "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1 && node tests/run_suite.js draft6 && node tests/run_suite.js draft2019-09",
     "test:compat": "node tests/test_compat.js",
     "test:standard-schema": "node tests/test_standard_schema.js",
     "test:browser": "node tests/test_browser.js",
@@ -123,6 +138,8 @@
     "index.mjs",
     "index.node.mjs",
     "index.browser.mjs",
+    "index.edge.js",
+    "index.edge.mjs",
     "index.d.ts",
     "aot.js",
     "aot.mjs",
@@ -147,18 +164,21 @@
     "lite.js",
     "lite.mjs",
     "lite.d.ts",
+    "error-runtime.js",
+    "error-runtime.mjs",
+    "error-runtime.d.ts",
     "bin/",
     "README.md",
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.48.0",
-    "@ata-validator/native-darwin-x64": "1.48.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.48.0",
-    "@ata-validator/native-linux-arm64-musl": "1.48.0",
-    "@ata-validator/native-linux-x64-gnu": "1.48.0",
-    "@ata-validator/native-linux-x64-musl": "1.48.0",
-    "@ata-validator/native-win32-x64": "1.48.0"
+    "@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"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"