ata-validator 1.52.0 → 1.54.0

package/lib/validator-core.js

@@ -33,12 +33,13 @@ let _aotLoader = null;
 function _registerAot(load) {
   _aotLoader = load;
 }
-const { draftCode, normalizeDraft2019, normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions } = require("./draft7");
-const { enabledKeywords, stripDisabledKeywords } = require("./vocabularies");
+// draft7.js, vocabularies.js, shape-classifier.js and tier0.js load where
+// they are first used: a fresh process validating a 2020-12 schema runs none
+// of their code, and reading them cost it about a tenth of what it loads.
+const _draft7 = () => require("./draft7");
+const _vocabularies = () => require("./vocabularies");
 const { needsNormalization } = require("./schema-scan");
-const { isV1Dialect } = require("./dialect");
-const { classify } = require("./shape-classifier");
-const { buildTier0Plan, tier0Validate } = require("./tier0");
+const { isV1Dialect, draftCode } = require("./dialect");
 
 // The closure defaults pass. Only a validator without the generated
 // preprocess pass calls it, so it loads on that first call; loading it with
@@ -424,11 +425,22 @@ function _deepCloneWithSymbols(v) {
     return a;
   }
   // Only clone plain objects (skip RegExp, Date, etc.).
-  if (Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null) return v;
-  const out = Object.create(null);
-  for (const k of Object.keys(v)) Object.defineProperty(out, k, { value: _deepCloneWithSymbols(v[k]), writable: true, enumerable: true, configurable: true });
-  for (const sym of Object.getOwnPropertySymbols(v)) out[sym] = v[sym];
-  return Object.setPrototypeOf(out, Object.prototype);
+  const proto = Object.getPrototypeOf(v);
+  if (proto !== Object.prototype && proto !== null) return v;
+  // An object literal, filled by assignment: building it without a prototype
+  // and setting one at the end left every copy in V8's slow dictionary mode,
+  // which made the copy and every walk over it slower. Only a key named
+  // `__proto__` needs defineProperty to stay an own property.
+  const out = {};
+  const keys = Object.keys(v);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    if (k === '__proto__') Object.defineProperty(out, k, { value: _deepCloneWithSymbols(v[k]), writable: true, enumerable: true, configurable: true });
+    else out[k] = _deepCloneWithSymbols(v[k]);
+  }
+  const syms = Object.getOwnPropertySymbols(v);
+  for (let i = 0; i < syms.length; i++) out[syms[i]] = v[syms[i]];
+  return out;
 }
 
 // Normalize a caller-provided schema without mutating the original.
@@ -436,11 +448,32 @@ function _deepCloneWithSymbols(v) {
 // 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.
+// Normalized results per schema object and dialect. A registry of hundreds of
+// schemas (an OpenAPI document's components, registered one by one) is
+// normalized again for every validator built over it when the map holding
+// them is a new object each time; the schemas themselves are the same objects,
+// and a schema is not changed after it is handed to a validator.
+const _normalized = new WeakMap()
 function _normalizeCallerSchema(s, inheritDraft7) {
+  if (s === null || typeof s !== 'object') return _normalizeCallerSchemaUncached(s, inheritDraft7)
+  const slot = inheritDraft7 || 0
+  let byDraft = _normalized.get(s)
+  if (byDraft !== undefined && byDraft[slot] !== undefined) return byDraft[slot]
+  const out = _normalizeCallerSchemaUncached(s, inheritDraft7)
+  // Only a copy is kept: a schema that needs nothing is answered by the scan
+  // alone, and remembering it cost every such validator a slot.
+  if (out !== s) {
+    if (byDraft === undefined) { byDraft = [undefined, undefined, undefined, undefined]; _normalized.set(s, byDraft) }
+    byDraft[slot] = out
+  }
+  return out
+}
+function _normalizeCallerSchemaUncached(s, 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 needsDraft7 = code === 1 || code === 2 || code === 4
+  const draft4 = code === 4
+  const draft6 = code === 2 || draft4
   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
@@ -450,17 +483,58 @@ function _normalizeCallerSchema(s, inheritDraft7) {
   // 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, draft6)
+  const { normalizeDraft7, normalizeDraft2019, normalizeNullable, normalizeExclusiveBounds } = _draft7()
+  if (needsDraft7) normalizeDraft7(copy, true, draft6, draft4)
   if (draft2019) normalizeDraft2019(copy, true)
   normalizeNullable(copy)
   normalizeExclusiveBounds(copy)
   // Return original when normalization produced no change, copy otherwise.
   // Kept even though the walk has already said there is work, so that a walk
   // which over-reports still returns exactly what it returned before.
-  // Change-detection uses JSON content only; symbols do not affect it.
-  return JSON.stringify(copy) === str ? s : copy
+  // Change-detection is JSON content, key order included; symbols do not
+  // affect it. Compared in place: serializing both took two passes over the
+  // whole document on every compile, most of the compile time of an OpenAPI
+  // document that inlines its components into each operation's schema, and
+  // a change is usually found in the first few nodes.
+  return _jsonEqual(s, copy) ? s : copy
+}
+
+// Whether `a` and `b` serialize to the same JSON, without serializing: the
+// copy is a clone of `a`, so anything the clone shares by reference (a
+// function, a RegExp) is the same on both sides.
+function _jsonEqual (a, b) {
+  if (a === b) return true
+  if (typeof a === 'number' && typeof b === 'number') return a !== a && b !== b
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false
+  const arr = Array.isArray(a)
+  if (arr !== Array.isArray(b)) return false
+  if (arr) {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) if (!_jsonEqual(a[i], b[i])) return false
+    return true
+  }
+  const ka = _jsonKeys(a), kb = _jsonKeys(b)
+  if (ka.length !== kb.length) return false
+  for (let i = 0; i < ka.length; i++) {
+    if (ka[i] !== kb[i]) return false
+    if (!_jsonEqual(a[ka[i]], b[kb[i]])) return false
+  }
+  return true
+}
+// The keys JSON.stringify writes: own enumerable ones whose value is not
+// undefined, a function or a symbol.
+function _jsonKeys (o) {
+  const keys = Object.keys(o)
+  let out = null
+  for (let i = 0; i < keys.length; i++) {
+    const v = o[keys[i]]
+    const t = typeof v
+    if (v === undefined || t === 'function' || t === 'symbol') {
+      if (out === null) out = keys.slice(0, i)
+    } else if (out !== null) out.push(keys[i])
+  }
+  return out === null ? keys : out
 }
 
 // The identity a document is registered under. Draft-07 ignores every
@@ -544,7 +618,11 @@ function _applyVocabularies(schemaObj, original, schemaMap) {
   if (!schemaObj || typeof schemaObj !== 'object') return schemaObj
   const declared = schemaObj.$schema
   if (typeof declared !== 'string') return schemaObj
-  const enabled = enabledKeywords(schemaMap.get(declared))
+  // Only a meta-schema with a $vocabulary can disable a keyword.
+  const meta = schemaMap.get(declared)
+  if (!meta || typeof meta !== 'object' || !meta.$vocabulary || typeof meta.$vocabulary !== 'object') return schemaObj
+  const { enabledKeywords, stripDisabledKeywords } = _vocabularies()
+  const enabled = enabledKeywords(meta)
   if (!enabled) return schemaObj
   // `original` is the caller's own object when it reached here unchanged, and
   // that one is never mutated.
@@ -650,7 +728,10 @@ function _materializeSchema(self) {
   }
   const isCallers = self._rawIsCallers && schemaObj === raw;
   if (options.assertFormat === false) {
-    schemaObj = stripFormatAssertions(isCallers ? _deepCloneWithSymbols(schemaObj) : schemaObj);
+    // Always on a copy: a normalized schema is shared by every validator built
+    // from the same object (see _normalizeCallerSchema), so stripping in place
+    // would take format checks away from the others.
+    schemaObj = _draft7().stripFormatAssertions(_deepCloneWithSymbols(schemaObj));
   }
   // A keyword used only in a schema reached through $ref counts too: the
   // interpreted engine applies it there, and every path that does not know the
@@ -952,7 +1033,10 @@ class Validator {
       // declines the schema, so does everything else, and the interpreted
       // engine answers alone, as it always did.
       const kw = this._keywords ? { keywords: this._keywords } : undefined;
-      const _cgFn = compileToJSCodegen(schemaObj, sm, uf, kw);
+      // A keyword that reads its data's context is only answered by the
+      // interpreted engine's collecting walk (see lib/keywords.js).
+      const ctxKw = this._usesKeywords && Object.keys(this._keywords).some((k) => this._keywords[k].dataContext);
+      const _cgFn = ctxKw ? null : compileToJSCodegen(schemaObj, sm, uf, kw);
       jsFn = _cgFn || (this._usesKeywords ? null : compileToJS(schemaObj, null, sm));
       // Only the verdict is compiled here. The error and combined generators
       // are the other two thirds of a cold first call (8.2, 10.4 and 7.8 ms on
@@ -1119,9 +1203,18 @@ class Validator {
         formats: this._userFormats,
         v1: isV1Dialect(schemaObj),
         keywords: this._keywords,
+        // compat's coercion where each type is checked (see the interpreter).
+        coerce: this._interpretOnly ? options._coerceInWalk : undefined,
+        discriminator: this._interpretOnly && options._discriminator === true,
+        numberFormats: this._interpretOnly ? options._numberFormats : undefined,
       });
       this._engine = 'interpreter';
-      if (!preprocess) this._fastVerdict = (d) => interp.isValid(d);
+      // A keyword that reads its data's context may also change the data (a
+      // request validator deserializing a date, say). Such a schema is run
+      // once per call: deciding first and walking again for the errors would
+      // run the keyword twice, the second time on what the first left.
+      const once = interp.dataContext === true;
+      if (!preprocess && !once) this._fastVerdict = (d) => interp.isValid(d);
       // abortEarly is a documented contract, not a property of whichever engine
       // answered: it promises the frozen ATA9000 stub instead of a detailed
       // error, so code that branches on it has to behave the same with and
@@ -1136,7 +1229,7 @@ class Validator {
             : (data) => interp.validate(data));
       this.validate = this._verbose ? _verboseWrap(run, schemaObj) : run;
       // Reading errors runs the interpreter once, directly; see _rejectBase.
-      if (!preprocess && !options.abortEarly && !this._verbose) _rejectBase = (data) => interp.validate(data);
+      if (!preprocess && !options.abortEarly && !this._verbose && !once) _rejectBase = (data) => interp.validate(data);
       _bindVerdict(this, this._fastVerdict
         ? this._fastVerdict
         : (data) => run(data).valid);
@@ -1146,7 +1239,7 @@ class Validator {
       // that the text path wraps around it: going through validate() as it
       // stands once every layer is in place handed the text path errors
       // already presented, and they lost their source anchor.
-      const runText = options.abortEarly
+      const runText = options.abortEarly || once
         ? run
         : (preprocess
             ? (data) => { preprocess(data); return interp.isValid(data) ? VALID_RESULT : interp.validate(data); }
@@ -2309,8 +2402,10 @@ _defineLazyMethod('isValidObject', (self) => {
     return self.isValidObject(data);
   }
   // Lazy: classify + build tier 0 plan on first call, not in constructor.
-  const _tier = classify(self._schemaObj);
+  const _tier = require("./shape-classifier").classify(self._schemaObj);
   if (_tier.tier === 0) {
+    // Bound once here, so the verdict below reads a local, not the module.
+    const { buildTier0Plan, tier0Validate } = require("./tier0");
     const _plan = buildTier0Plan(self._schemaObj);
     let _n = 0;
     _bindVerdict(self, (d) => {

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.52.0",
+  "version": "1.54.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",
@@ -88,7 +88,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 && node tests/run_suite.js draft6 && node tests/run_suite.js draft2019-09",
+    "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 && node tests/run_suite.js draft4",
     "test:compat": "node tests/test_compat.js",
     "test:standard-schema": "node tests/test_standard_schema.js",
     "test:browser": "node tests/test_browser.js",
@@ -174,13 +174,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@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"
+    "@ata-validator/native-darwin-arm64": "1.54.0",
+    "@ata-validator/native-darwin-x64": "1.54.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.54.0",
+    "@ata-validator/native-linux-arm64-musl": "1.54.0",
+    "@ata-validator/native-linux-x64-gnu": "1.54.0",
+    "@ata-validator/native-linux-x64-musl": "1.54.0",
+    "@ata-validator/native-win32-x64": "1.54.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"