ata-validator 1.52.0 → 1.53.0

package/lib/plan-compiler.js

@@ -532,8 +532,11 @@ function install(deps) {
           const key = keys[k];
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
+          // A declared property whose value is undefined is not checked (see
+          // the interpreter's eval).
           if (prop !== undefined) {
-            if (!((prop.fn.leaf && prop.fn.v(data[key], stack)) || prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
+            const value = data[key];
+            if (value !== undefined && !((prop.fn.leaf && prop.fn.v(value, stack)) || prop.fn.c(value, errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -578,7 +581,8 @@ function install(deps) {
           for (let i = 0; i < n; i++) {
             const key = propKeys[i];
             if (!Object.hasOwn(data, key)) continue;
-            if (!propList[i].fn.v(data[key], stack)) return false;
+            const value = data[key];
+            if (value !== undefined && !propList[i].fn.v(value, stack)) return false;
             if (collect) addProp(rec, key);
           }
           return true;
@@ -594,7 +598,8 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
-            if (!prop.fn.v(data[key], stack)) return false;
+            const value = data[key];
+            if (value !== undefined && !prop.fn.v(value, stack)) return false;
             evaluated = true;
           }
           if (patterns !== null) {

package/lib/schema-scan.js

@@ -30,6 +30,24 @@ const TUPLE_ITEMS = 1 << 5;      // array-valued `items`, split into `prefixItem
 const EXCLUSIVE_BOOL = 1 << 6;   // draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum`
 const ENCODED_REF = 1 << 7;      // a fragment `$ref` holding a percent escape, decoded by normalizeNullable's walk
 
+// Questions compat asks of a schema it is about to compile (compat.js), read
+// on the same walk so that a document is not walked again for them.
+const HAS_REF = 1 << 8;          // `$ref` anywhere
+const BEYOND_ITEMS = 1 << 9;     // a subschema keyword other than `properties` and object `items`
+const DISCRIMINATOR = 1 << 10;   // `discriminator` anywhere
+const HAS_DEFAULT = 1 << 11;     // `default` anywhere
+const HAS_ALLOF = 1 << 12;       // `allOf` anywhere
+const HAS_FORMAT = 1 << 13;      // `format` anywhere
+const KEY_BITS = new Map([
+  ['$ref', HAS_REF | BEYOND_ITEMS], ['$dynamicRef', BEYOND_ITEMS], ['allOf', HAS_ALLOF | BEYOND_ITEMS],
+  ['anyOf', BEYOND_ITEMS], ['oneOf', BEYOND_ITEMS], ['not', BEYOND_ITEMS], ['if', BEYOND_ITEMS],
+  ['then', BEYOND_ITEMS], ['else', BEYOND_ITEMS], ['additionalProperties', BEYOND_ITEMS],
+  ['patternProperties', BEYOND_ITEMS], ['prefixItems', BEYOND_ITEMS], ['additionalItems', BEYOND_ITEMS],
+  ['contains', BEYOND_ITEMS], ['dependentSchemas', BEYOND_ITEMS], ['dependencies', BEYOND_ITEMS],
+  ['propertyNames', BEYOND_ITEMS], ['unevaluatedProperties', BEYOND_ITEMS], ['unevaluatedItems', BEYOND_ITEMS],
+  ['discriminator', DISCRIMINATOR], ['default', HAS_DEFAULT], ['format', HAS_FORMAT],
+]);
+
 // Everything only draft-07 normalization acts on. A schema of another dialect
 // can carry these without them meaning anything, so they are read together
 // with whether the document is draft-07 at all.
@@ -92,7 +110,11 @@ function scan(schema) {
     }
     // Every key, not just the subschema keywords, so this cannot miss a place
     // the normalizers would reach.
-    for (let i = 0; i < keys.length; i++) walk(node[keys[i]]);
+    for (let i = 0; i < keys.length; i++) {
+      const b = KEY_BITS.get(keys[i]);
+      if (b !== undefined) bits |= b;
+      walk(node[keys[i]]);
+    }
   };
 
   walk(schema);
@@ -124,4 +146,10 @@ module.exports = {
   EXCLUSIVE_BOOL,
   ENCODED_REF,
   DRAFT7_WORK,
+  HAS_REF,
+  BEYOND_ITEMS,
+  DISCRIMINATOR,
+  HAS_DEFAULT,
+  HAS_ALLOF,
+  HAS_FORMAT,
 };

package/lib/validator-core.js

@@ -424,11 +424,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,7 +447,27 @@ 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
@@ -450,7 +481,6 @@ 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)
   if (draft2019) normalizeDraft2019(copy, true)
@@ -459,8 +489,49 @@ function _normalizeCallerSchema(s, inheritDraft7) {
   // 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
@@ -650,7 +721,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 = 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 +1026,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 +1196,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 +1222,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 +1232,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); }

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.53.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.52.0",
+  "version": "1.53.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",
@@ -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.53.0",
+    "@ata-validator/native-darwin-x64": "1.53.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.53.0",
+    "@ata-validator/native-linux-arm64-musl": "1.53.0",
+    "@ata-validator/native-linux-x64-gnu": "1.53.0",
+    "@ata-validator/native-linux-x64-musl": "1.53.0",
+    "@ata-validator/native-win32-x64": "1.53.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"