ata-validator 1.60.0 → 1.61.1

package/lib/rejections.js

@@ -1,13 +1,12 @@
 'use strict';
 
-// The rejection objects validate() and validateJSON() return, and the helpers
+// The rejection objects validate() returns, and the helpers
 // that build their errors on first read: declaration-order sorting,
 // enrichment, typo correlation and source frames. Shared by the validator core
 // and by the wrapper around a compiled module, so both report errors through
-// the same code.
+// the same code. The one validateJSON() returns is in lib/json-rejections.js.
 
 const { ordinalFor: schemaOrdinal, rankFor: schemaRank } = require('./schema-order');
-const { setDiagnosticSource: attachDiagnosticSource } = require('./diagnostic-source');
 
 // Rejection result with errors materialized on first read. The accessor
 // lives on the prototype so constructing one is a plain allocation; an
@@ -80,6 +79,15 @@ class RichRejection {
     return raw;
   }
 }
+// The position map builder of lib/json-rejections.js, which sets it when it
+// loads. Only validateJSON passes JSON text here, and the code that calls it
+// loads that module first (were it not, the call below throws, it does not
+// skip the frames); validate() and a compiled wrapper without the JSON
+// entry points never load it, so their bundles carry neither it nor the
+// rejection validateJSON returns (532 bytes gzipped of the wrapper).
+let _positionsFor = null;
+function _setPositionsFor (fn) { _positionsFor = fn; }
+
 // Orders a raw error list and gives it the shape the caller asked for: the
 // legacy key set, or enriched. Shared by both rejection classes below.
 function presentErrors(raw, data, rawInput, self, root, enrich) {
@@ -87,7 +95,7 @@ function presentErrors(raw, data, rawInput, self, root, enrich) {
   // The position map, resolved on the first read of an error's frame (see
   // defineLazyFrames in lib/enrich-error.js): a walk of the document that a
   // caller reading messages and paths never needs.
-  const lazyPositions = enrich && raw.length && rawInput != null ? lazyPositionsFor(self, rawInput, raw) : null;
+  const lazyPositions = enrich && raw.length && rawInput != null ? _positionsFor(self, rawInput, raw) : null;
   // One options object for the whole list, not one per error.
   const opts = enrich && raw.length
     ? {
@@ -126,153 +134,6 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
 });
 
 
-// The rejection validateJSON returns. Everything the text path adds over
-// validate(data), the value tree enrichment needs, the position map, the
-// diagnostic payload, happens on first access to `.errors`. Reading `.valid`
-// touches none of it. The JSON text is held here rather than read back off the
-// validator, so the result does not depend on what the instance does next.
-class LazyJsonRejection {
-  // `parsed`, when given, is the document the inner path parsed from
-  // `jsonStr` and validated, after defaults, coercion and removal: reading the
-  // errors uses it instead of parsing the text again, which on a 5 MB
-  // document was a third of what reading them cost.
-  constructor(result, jsonStr, self, enrich, parsed) {
-    this.valid = false;
-    this._result = result;
-    this._jsonStr = jsonStr;
-    this._self = self;
-    this._enrich = enrich;
-    this._cached = null;
-    this._parsed = parsed;
-  }
-  toJSON() {
-    return { valid: false, errors: this.errors };
-  }
-}
-Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
-  enumerable: true,
-  configurable: true,
-  get() {
-    if (this._cached !== null) return this._cached;
-    const self = this._self;
-    const enrich = this._enrich;
-    const jsonStr = this._jsonStr;
-    // Reading the inner errors realizes the inner lazy layer, if there was one.
-    const raw = this._result.errors || [];
-    if (!raw.length) { this._cached = raw; return raw; }
-
-    // The enrich pass plucks `received` from the value tree and the suggestion
-    // engine (required-typo, format hints, coercion nudges) walks it too.
-    let parsedData = this._parsed;
-    if (parsedData === undefined) {
-      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
-      // What was checked is the document after defaults, coercion and removal,
-      // so `received` has to come from that, as it does for validate(). A
-      // default that failed its own schema has no value in the text at all.
-      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
-    }
-
-    // Errors the inner path already enriched carry a `received` key: enrich()
-    // always sets one, even when there is no value to show. `code` is not a
-    // safe signal, because branch-collapse attaches codes to raw errors, and
-    // `docUrl` is not either, because the generated error functions stamp it
-    // on raw errors; taking it as the signal left those errors without
-    // `received` or a suggestion on the text path while validate() had both.
-    if (!raw[0] || !('received' in raw[0])) {
-      // Declaration order, as validate() applies it; the text path used to
-      // enrich in emission order.
-      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
-      // The position map waits for the first read of a frame (lib/enrich-error
-      // defineLazyFrames); until then reading the list costs the enrichment alone.
-      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
-      const enrichOpts = {
-        data: parsedData,
-        positions: null,
-        lazyPositions,
-        schemaPositions: self._schemaPositions,
-        schemaFile: self._source ? self._source.path : undefined,
-      };
-      const enriched = ordered.map((e) => enrich(e, enrichOpts));
-      if (enriched.length > 1) attachRelated(enriched);
-      attachDiagnosticSource(enriched, {
-        data: parsedData,
-        text: jsonStr,
-        // Read by the diagnostic renderer only, which resolves the same map.
-        get positions () { return lazyPositions(); },
-        schema: self._schemaObj,
-        mutatesInput: self._mutatesInput === true,
-      });
-      this._cached = enriched;
-      return enriched;
-    }
-
-    // Already enriched, so the frames are usually attached too. Only a gap in
-    // them is worth another walk of the document: resolving the map to discover
-    // there was nothing to fill cost a second full walk on every rejection.
-    if (raw.some((e) => e && !e.dataFrame)) {
-      const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw.filter((e) => e && !e.dataFrame)));
-      if (positions) {
-        for (const e of raw) {
-          if (e && !e.dataFrame) {
-            const path = e.path != null ? e.path : (e.instancePath || '');
-            const p = positions[path];
-            if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
-          }
-        }
-        self._posCache.reset();
-      }
-    }
-    if (raw.length > 1) attachRelated(raw);
-    attachDiagnosticSource(raw, {
-      data: parsedData,
-      text: jsonStr,
-      schema: self._schemaObj,
-      mutatesInput: self._mutatesInput === true,
-    });
-    this._cached = raw;
-    return raw;
-  },
-});
-
-// The targeted position map for a list, built on the first call and shared
-// by every error's frame accessor (lib/enrich-error defineLazyFrames).
-function lazyPositionsFor (self, text, errors) {
-  let done = false;
-  let positions = null;
-  return () => {
-    if (done) return positions;
-    done = true;
-    positions = self._pos().targeted(text, wantedPointersFor(errors));
-    if (positions) self._posCache.reset();
-    return positions;
-  };
-}
-
-// The pointers a set of errors will ask the position map about. lib/enrich-error
-// looks up the error's own path, and for an additional or unevaluated property
-// the child pointer named in `params`, unescaped, which is the form it asks for.
-// The escaped form goes in too: including a pointer that is never read costs
-// nothing, and the cache answers anything outside this set from the full map
-// rather than reporting no position.
-function wantedPointersFor (errors) {
-  const wanted = new Set();
-  for (const e of errors) {
-    if (!e) continue;
-    const path = e.path != null ? e.path : (e.instancePath || '');
-    wanted.add(path);
-    if (e.instancePath != null && e.instancePath !== path) wanted.add(e.instancePath);
-    const params = e.params;
-    const named = params && (params.additionalProperty || params.unevaluatedProperty);
-    if (typeof named === 'string') {
-      wanted.add(path + '/' + named);
-      if (named.indexOf('~') !== -1 || named.indexOf('/') !== -1) {
-        wanted.add(path + '/' + named.replace(/~/g, '~0').replace(/\//g, '~1'));
-      }
-    }
-  }
-  return wanted;
-}
-
 // A raw error in the legacy shape. The error generator writes `code` and
 // `docUrl` into its literals because a standalone module returns them as they
 // are; the runtime's legacy shape never had them, and the interpreter leaves
@@ -411,4 +272,4 @@ function attachRelated (errors) {
   return errors;
 }
 
-module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, LazyJsonRejection, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, wantedPointersFor };
+module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, _setPositionsFor };

package/lib/standard-schema.js

@@ -117,7 +117,7 @@ function standardSchemaFor(self, getSchema, validate) {
         if (!message) {
           // The native engine reports numeric codes without a message; the
           // enrich pass knows how to word those. Rare, so required lazily.
-          message = require('./enrich-error').enrich(err, {}).message;
+          message = require('./native-message')(err);
         }
         issues[i] = { message, path: parsePointerPath(path) };
       }

package/lib/tier0.js

@@ -47,7 +47,7 @@ const F_MULT = 16;
 const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
 const _hop = Object.prototype.hasOwnProperty;
 // Deno removes the __proto__ accessor; read the prototype another way there.
-const _PN = ({}).__proto__ === Object.prototype;
+const _PN = typeof Bun === 'undefined' && ({}).__proto__ === Object.prototype; // JavaScriptCore goes through Object.getPrototypeOf, see js-compiler's _PN
 
 function primConstraint(key, propSchema) {
   const t = propSchema.type;

package/lib/validator-core.js

@@ -19,6 +19,14 @@ const { normalizeKeywords, schemaUsesKeywords } = require('./keywords');
 // bundle built from lite.js never contains it. Until something registers, the
 // core behaves exactly as it does where `new Function` is blocked: every
 // schema runs on the interpreted engine, which passes the same test suite.
+// Whether this process runs code compiled ahead of time, where generated
+// code falls to an interpreter: Bun's flag for its compiler, or the
+// environment saying so (an executable built before the flag existed).
+function aotHost() {
+  if (env('ATA_ENGINE') === 'interpreter') return true;
+  const b = typeof Bun !== 'undefined' ? Bun : undefined;
+  return !!(b && b.isAOT === true);
+}
 let _codegen = null;
 let compileToJS, compileToJSCodegen, compileToJSCodegenWithErrors, compileToJSCombined;
 function _registerCodegen(engine) {
@@ -37,6 +45,10 @@ let _aotLoader = null;
 // index.browser.mjs, null in every other entry, which then carry none of it.
 let _tiering = null;
 function _registerTiering(t) { _tiering = t; }
+// Called with each validator the constructor finishes. The Node entry uses it
+// to warm the engine once the event loop is free (see index.js).
+let _onBuilt = null;
+function _registerBuiltHook(f) { _onBuilt = f; }
 function _registerAot(load) {
   _aotLoader = load;
 }
@@ -341,7 +353,14 @@ function resolveSchemaByPath(rootSchema, schemaPath) {
 // by every page that loads the package, validating or not.
 let LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal;
 function _loadRejections() {
-  ({ LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections'));
+  ({ LazyRejection, RichRejection, _enrichLazy, presentErrors, needsOrdering, sortErrorsBySchemaOrder, stripOrdinal } = require('./rejections'));
+}
+// The rejection validateJSON returns, and the position map an error's frame
+// reads, loaded with the first rejection that carries JSON text: a process
+// that only ever calls validate() never parses them (lib/json-rejections.js,
+// lib/diagnostic-source.js).
+function _loadJsonRejections() {
+  if (LazyJsonRejection === undefined) ({ LazyJsonRejection } = require('./json-rejections'));
 }
 
 // Text that does not parse, reported the same way on every path and platform:
@@ -772,7 +791,13 @@ class Validator {
     if (options.engine !== undefined && options.engine !== 'auto' && options.engine !== 'interpreter') {
       throw new TypeError("engine must be 'auto' or 'interpreter', got " + JSON.stringify(options.engine));
     }
-    this._interpretOnly = options.engine === 'interpreter';
+    // Under an ahead-of-time compiler the generated code is interpreted and
+    // the interpreted engine, plain JavaScript, is compiled: measured on
+    // Bun's compiler, 80 against 530 ns a document. So the default flips
+    // there: Bun.isAOT once Bun ships it, ATA_ENGINE=interpreter until then
+    // and for any other host. `engine: 'auto'` asked for by name keeps the
+    // generated code.
+    this._interpretOnly = options.engine === 'interpreter' || (options.engine === undefined && aotHost());
     this._initialized = false;
     this._nativeReady = false;
     this._compiled = null;
@@ -861,8 +886,10 @@ class Validator {
     this._verdictTail = null;
     this._validateTail = null;
     this._entryExt = null;
-    // The browser build warms the engine once, when the page is idle (lib/tiering.js).
+    // The browser build warms the engine once, when the page is idle (lib/tiering.js);
+    // the Node entry does the same once the event loop is free (index.js).
     if (_tiering !== null) _tiering.built(this);
+    if (_onBuilt !== null) _onBuilt(this);
 
     // Public methods start as memoized accessors on the prototype; nothing is
     // allocated per instance until one is first read. See _defineLazyMethod
@@ -950,7 +977,10 @@ class Validator {
 
     // Check cache first -- reuse compiled functions for same schema
     const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
-    const mapKey = compileCacheKey(this._schemaStr, this._schemaMap);
+    // The generated code takes the form of the target engine (js-compiler's
+    // setTargetEngine), so a function written for one engine is never handed
+    // to a compile asked for the other in the same process.
+    const mapKey = compileCacheKey(this._schemaStr, this._schemaMap) + '\u0000' + (_codegen && _codegen.jsCompiler && typeof _codegen.jsCompiler.targetEngine === 'function' ? _codegen.jsCompiler.targetEngine() : 'v8');
     var _forceNapi = this._interpretOnly || env('ATA_FORCE_NAPI');
     // Custom formats are JS functions: bypass the compile cache since they can
     // differ between validators that share the same schema string. An
@@ -1261,6 +1291,7 @@ class Validator {
           // literal with a getter here cost a closure plus an accessor
           // definition on every rejection, several hundred nanoseconds
           // before any error was read.
+          if (rawInput != null) _loadJsonRejections();
           return new RichRejection(result, data, rawInput, self, root, enrich);
         }
         return result;
@@ -1297,6 +1328,7 @@ class Validator {
           // and on the codegen path that realizes the inner lazy layer, which is
           // the document walk this exists to avoid.
           if (result && result.valid === false) {
+            _loadJsonRejections();
             return new LazyJsonRejection(result, jsonStr, this, enrich, parsed);
           }
           return result;
@@ -1913,6 +1945,14 @@ function compile(schema, opts) {
 // JSONSchema type (see index.d.ts) to an inline schema object so TypeScript
 // gives autocomplete and value checking while authoring. Returns the schema
 // untouched so it can be passed straight to Validator, toStandaloneModule, etc.
+// `schemaOf<T>()`: the JSON Schema of a TypeScript type, written in by
+// @ata-project/unplugin at build time from the type and its JSDoc tags. It
+// has no run-time form: a call that reaches here was not replaced, and the
+// loud error is better than an empty schema that accepts everything.
+function schemaOf () {
+  throw new Error('schemaOf<T>() is replaced at build time by @ata-project/unplugin (with ts-json-schema-generator installed); it has no run-time form. Write the JSON Schema, or build with the plugin.');
+}
+
 function defineSchema (schema) {
   return schema;
 }
@@ -2402,12 +2442,14 @@ module.exports = {
   SIMDJSON_PADDING,
   parseJSON,
   defineSchema,
+  schemaOf,
 };
 // 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, '_setCodegenLoader', { value: (load) => { _loadCodegen = load; }, enumerable: false });
 Object.defineProperty(module.exports, '_registerTiering', { value: _registerTiering, enumerable: false });
+Object.defineProperty(module.exports, '_registerBuiltHook', { value: _registerBuiltHook, enumerable: false });
 Object.defineProperty(module.exports, '_codegenRegistered', { value: () => _codegen !== null, enumerable: false });
 Object.defineProperty(module.exports, '_tiering', { get: () => _tiering, enumerable: false });
 Object.defineProperty(module.exports, '_registerAot', { value: _registerAot, enumerable: false });