ata-validator 1.35.0 → 1.36.0

package/build.d.ts

@@ -155,3 +155,26 @@ export function schemaHash(schema: unknown): string;
  * schema, plus `parse` when {@link ToStandaloneModuleOptions.parse} is set
  * and `validateJSON` when {@link ToStandaloneModuleOptions.positions} is. */
 export function toStandaloneModule(schema: unknown, options?: ToStandaloneModuleOptions): string | null;
+
+/**
+ * Whether `new Validator(schema)` with default options can be replaced by
+ * `fromCompiled()` from `ata-validator/compiled`. False for a schema with
+ * custom `errorMessage`s. A caller also needs {@link compiledModuleFor} to
+ * return a module.
+ */
+export function compiledEligible(schema: unknown): boolean;
+
+/**
+ * The schema a default `Validator` reads after normalization. Pass it to
+ * `fromCompiled()`, so defaults, error order and diagnostics follow the same
+ * document the runtime does.
+ */
+export function compiledSchemaFor(schema: unknown): object;
+
+/**
+ * The module that replaces `new Validator(schema)`, or null where the
+ * replacement would not answer as the runtime does: a schema
+ * {@link compiledEligible} declines, one the emitter cannot compile, and one
+ * whose detailed errors the generator cannot produce.
+ */
+export function compiledModuleFor(schema: unknown, opts?: { format?: 'esm' | 'cjs' }): string | null;

package/build.mjs

@@ -8,4 +8,8 @@ export const watch = mod.watch;
 export const bundleStandalone = mod.bundleStandalone;
 export const bundleCompact = mod.bundleCompact;
 export const toStandaloneModule = mod.toStandaloneModule;
+export const schemaHash = mod.schemaHash;
+export const compiledEligible = mod.compiledEligible;
+export const compiledSchemaFor = mod.compiledSchemaFor;
+export const compiledModuleFor = mod.compiledModuleFor;
 export default mod;

package/index.d.ts

@@ -407,6 +407,12 @@ export interface ValidatorOptions {
    * `'log'` warns through `logger` (or the console) and continues.
    */
   strictSchema?: boolean | 'log';
+  /**
+   * The URI the schema was retrieved from. Relative references resolve against
+   * it when the schema declares no `$id` of its own, including a draft-07 root
+   * whose `$id` sits beside a `$ref` and is therefore ignored.
+   */
+  baseURI?: string;
   /** Receives `strictSchema: 'log'` warnings; `false` silences them. */
   logger?: { warn(...args: unknown[]): void } | false;
   /**

package/index.js

@@ -568,11 +568,117 @@ function emitRemovals(node, access, lines, depth, seen) {
   else lines.push(`if(${access}!==null&&typeof ${access}==='object'&&!Array.isArray(${access})){${body.join('\n')}}`);
 }
 
+// The coercions the closure pass applies, emitted. Values: `number` and
+// `integer` from numeric strings and booleans, `string` from numbers and
+// booleans, `boolean` from "true"/"1" and "false"/"0".
+const COERCIBLE_TYPES = new Set(['number', 'integer', 'string', 'boolean']);
+function scalarCoercion(a, t) {
+  if (t === 'integer') return [`if(typeof ${a}==='string'){var _n=Number(${a});if(${a}!==''&&Number.isInteger(_n))${a}=_n}`, `if(typeof ${a}==='boolean')${a}=${a}?1:0`];
+  if (t === 'number') return [`if(typeof ${a}==='string'){var _n=Number(${a});if(${a}!==''&&!isNaN(_n))${a}=_n}`, `if(typeof ${a}==='boolean')${a}=${a}?1:0`];
+  if (t === 'string') return [`if(typeof ${a}==='number'||typeof ${a}==='boolean')${a}=String(${a})`];
+  return [`if(${a}==='true'||${a}==='1')${a}=true`, `if(${a}==='false'||${a}==='0')${a}=false`];
+}
+function isScalarCoercible(node) {
+  return !!(node && typeof node === 'object' && typeof node.type === 'string' && COERCIBLE_TYPES.has(node.type));
+}
+// Whether anything below `node` is coerced, as buildNodeCoercer decides it.
+// Remembered per node for the build, since every enclosing node asks again.
+function coercesInside(node, seen, memo) {
+  if (!node || typeof node !== 'object' || seen.has(node)) return false;
+  if (memo && memo.has(node)) return memo.get(node);
+  seen.add(node);
+  let found = false;
+  if (node.properties) {
+    for (const [key, prop] of Object.entries(node.properties)) {
+      if (key === '__proto__' || !prop || typeof prop !== 'object') continue;
+      if (isScalarCoercible(prop) || coercesInside(prop, seen, memo)) { found = true; break; }
+    }
+  }
+  if (!found && node.items && typeof node.items === 'object' && !Array.isArray(node.items)) {
+    found = isScalarCoercible(node.items) || coercesInside(node.items, seen, memo);
+  }
+  seen.delete(node);
+  if (memo) memo.set(node, found);
+  return found;
+}
+function emitCoercions(node, ov, lines, st, depth) {
+  if (st.seen.has(node)) { st.cycle = true; return; }
+  st.seen.add(node);
+  if (node.properties) {
+    for (const [key, prop] of Object.entries(node.properties)) {
+      // Coercion writes with plain assignment, which for a key named
+      // __proto__ rewrites the prototype instead. The raw value still goes
+      // through validation, so skipping is a refusal to coerce, not a hole.
+      if (key === '__proto__' || !prop || typeof prop !== 'object') continue;
+      const k = JSON.stringify(key);
+      const a = `${ov}[${k}]`;
+      if (isScalarCoercible(prop)) lines.push(...scalarCoercion(a, prop.type));
+      // Wrapping a lone value in an array is a top-level rule only, as it was.
+      else if (depth === 0 && prop.type === 'array' && st.arrayMode) lines.push(`if(${k} in ${ov}&&${a}!==undefined&&!Array.isArray(${a}))${a}=[${a}]`);
+      // A leaf, the common case, has nothing below it to coerce.
+      if ((prop.properties || prop.items) && coercesInside(prop, new Set(), st.memo)) {
+        const n = '_c' + st.n++;
+        lines.push(`{const ${n}=${a};if(typeof ${n}==='object'&&${n}!==null){`);
+        emitCoercions(prop, n, lines, st, depth + 1);
+        lines.push('}}');
+      }
+    }
+  }
+  const it = node.items;
+  if (it && typeof it === 'object' && !Array.isArray(it) && (isScalarCoercible(it) || coercesInside(it, new Set(), st.memo))) {
+    const i = '_i' + st.n++;
+    lines.push(`if(Array.isArray(${ov}))for(let ${i}=0;${i}<${ov}.length;${i}++){`);
+    if (isScalarCoercible(it)) lines.push(...scalarCoercion(`${ov}[${i}]`, it.type));
+    if (coercesInside(it, new Set(), st.memo)) {
+      const n = '_c' + st.n++;
+      lines.push(`{const ${n}=${ov}[${i}];if(typeof ${n}==='object'&&${n}!==null){`);
+      emitCoercions(it, n, lines, st, depth + 1);
+      lines.push('}}');
+    }
+    lines.push('}');
+  }
+  st.seen.delete(node);
+}
+function hasDefaultsInside(node, seen) {
+  if (!node || typeof node !== 'object' || !node.properties || seen.has(node)) return false;
+  seen.add(node);
+  let found = false;
+  for (const prop of Object.values(node.properties)) {
+    if (prop && typeof prop === 'object' && (prop.default !== undefined || hasDefaultsInside(prop, seen))) { found = true; break; }
+  }
+  seen.delete(node);
+  return found;
+}
+function emitDefaults(node, ov, lines, st) {
+  if (st.seen.has(node)) { st.cycle = true; return; }
+  st.seen.add(node);
+  for (const [key, prop] of Object.entries(node.properties || {})) {
+    if (!prop || typeof prop !== 'object') continue;
+    const k = JSON.stringify(key);
+    if (prop.default !== undefined) {
+      const def = JSON.stringify(prop.default);
+      // Assignment to a key named __proto__ hits the prototype setter
+      // instead of creating a property; defineProperty writes an own key.
+      lines.push(key === '__proto__'
+        ? `if(!Object.hasOwn(${ov},${k}))Object.defineProperty(${ov},${k},{value:${def},writable:true,enumerable:true,configurable:true})`
+        : `if(!Object.hasOwn(${ov},${k}))${ov}[${k}]=${def}`);
+    }
+    // Into an own property that holds an object, arrays included, as the
+    // closure pass walks it.
+    if (prop.properties && hasDefaultsInside(prop, new Set())) {
+      const n = '_d' + st.n++;
+      lines.push(`if(Object.hasOwn(${ov},${k})){const ${n}=${ov}[${k}];if(typeof ${n}==='object'&&${n}!==null){`);
+      emitDefaults(prop, n, lines, st);
+      lines.push('}}');
+    }
+  }
+  st.seen.delete(node);
+}
+
 // Generate a fast preprocess function via codegen instead of closure arrays
 function buildPreprocessCodegen(schema, options) {
   if (typeof schema !== 'object' || schema === null || !schema.properties) return null;
   const lines = [];
-  const props = schema.properties;
 
   // removeAdditional: strip unknown keys at every level the schema describes,
   // not just the top one. The closure path below (collectRemovals) always
@@ -584,59 +690,44 @@ function buildPreprocessCodegen(schema, options) {
     emitRemovals(schema, 'd', lines, 0, new Set());
   }
 
-  // coerceTypes: inline per property
-  if (options.coerceTypes) {
-    for (const [key, prop] of Object.entries(props)) {
-      if (!prop || typeof prop !== 'object' || !prop.type) continue;
-      // Coercion writes with plain assignment, which for a key named
-      // __proto__ rewrites the prototype instead. The raw value still goes
-      // through validation, so skipping is a refusal to coerce, not a hole.
-      if (key === '__proto__') continue;
-      const t = Array.isArray(prop.type) ? null : prop.type;
-      if (!t) continue;
-      const k = JSON.stringify(key);
-      if (t === 'integer') {
-        lines.push(`if(typeof d[${k}]==='string'){var _n=Number(d[${k}]);if(d[${k}]!==''&&Number.isInteger(_n))d[${k}]=_n}`);
-        lines.push(`if(typeof d[${k}]==='boolean')d[${k}]=d[${k}]?1:0`);
-      } else if (t === 'number') {
-        lines.push(`if(typeof d[${k}]==='string'){var _n=Number(d[${k}]);if(d[${k}]!==''&&!isNaN(_n))d[${k}]=_n}`);
-        lines.push(`if(typeof d[${k}]==='boolean')d[${k}]=d[${k}]?1:0`);
-      } else if (t === 'string') {
-        lines.push(`if(typeof d[${k}]==='number'||typeof d[${k}]==='boolean')d[${k}]=String(d[${k}])`);
-      } else if (t === 'boolean') {
-        lines.push(`if(d[${k}]==='true'||d[${k}]==='1')d[${k}]=true`);
-        lines.push(`if(d[${k}]==='false'||d[${k}]==='0')d[${k}]=false`);
-      } else if (t === 'array' && options.coerceTypes === 'array') {
-        lines.push(`if(${k} in d&&d[${k}]!==undefined&&!Array.isArray(d[${k}]))d[${k}]=[d[${k}]]`);
-      }
-    }
-  }
-
-  // defaults: inline per property
-  if (options.useDefaults !== false) {
-    for (const [key, prop] of Object.entries(props)) {
-      if (prop && typeof prop === 'object' && prop.default !== undefined) {
-        const k = JSON.stringify(key);
-        const def = JSON.stringify(prop.default);
-        // Assignment to a key named __proto__ hits the prototype setter
-        // instead of creating a property; defineProperty writes an own key.
-        lines.push(key === '__proto__'
-          ? `if(!Object.hasOwn(d,${k}))Object.defineProperty(d,${k},{value:${def},writable:true,enumerable:true,configurable:true})`
-          : `if(!Object.hasOwn(d,${k}))d[${k}]=${def}`);
-      }
-    }
-  }
+  // Coercion and defaults reach every depth the closure passes in
+  // validator-core.js reach, with the same rules in the same order, so the
+  // interpreted engine, which uses those passes, gives the same answer. Both
+  // used to stop at the top-level properties. A schema object that contains
+  // itself declines here, and the closure passes, which carry a guard for it,
+  // take the schema.
+  const st = { n: 0, seen: new Set(), cycle: false, arrayMode: options.coerceTypes === 'array', memo: new Map() };
+  if (options.coerceTypes) emitCoercions(schema, 'd', lines, st, 0);
+  // hasDefaultsInside answers without emitting; most schemas have no default,
+  // and the emitting walk allocates for every property it visits.
+  if (options.useDefaults !== false && hasDefaultsInside(schema, new Set())) emitDefaults(schema, 'd', lines, st);
+  if (st.cycle) return null;
 
   if (lines.length === 0) return null;
   // Data may legitimately be null or a non-object (e.g. a `['object','null']`
   // schema), so the per-property mutations must not run on it.
   lines.unshift(`if(d===null||typeof d!=='object')return`);
-  try {
-    return new Function('d', lines.join('\n'));
-  } catch {
-    return null;
+  // The pass depends on property names, types, defaults and which objects
+  // are closed, not on the constraints the verdict checks, so routes that
+  // take the same shape with different limits (a page/limit querystring, an
+  // id param) emit the same source. Compiling it is most of what building the
+  // pass costs, so the function is kept by its source and compiled once. It
+  // holds no state: it rewrites the object it is given and nothing else.
+  const src = lines.join('\n');
+  let fn = _preprocessBySource.get(src);
+  if (fn === undefined) {
+    try {
+      fn = new Function('d', src);
+    } catch {
+      fn = null;
+    }
+    if (_preprocessBySource.size >= PREPROCESS_SOURCE_LIMIT) _preprocessBySource.clear();
+    _preprocessBySource.set(src, fn);
   }
+  return fn;
 }
+const _preprocessBySource = new Map();
+const PREPROCESS_SOURCE_LIMIT = 4096;
 
 
 // parse() for the full package: a generated function that copies the keys the

package/index.node.mjs

@@ -0,0 +1,10 @@
+// The ESM entry Node itself resolves (the `module-sync` condition, Node 22.10
+// and later). Importing index.js with an `import` statement makes Node run
+// its CommonJS lexer over every module the package requires, to find named
+// exports this file lists by hand anyway: 7.7 ms to load against 5.5 through
+// require. Bundlers do not match `module-sync` and keep index.mjs, whose
+// static import they can follow.
+import { createRequire } from 'node:module';
+const mod = createRequire(import.meta.url)('./index.js');
+export const { Validator, compile, validate, validateAsync, parseAsync, version, createPaddedBuffer, SIMDJSON_PADDING, parseJSON, toTypeScript, defineSchema, renderPretty, renderCompact, toOutput, toRetryMessage, describeSchema, renderJSON } = mod;
+export default mod;

package/lib/aot-build.js

@@ -292,17 +292,22 @@ const { schemaHash } = require('./schema-hash');
 // fromCompiled() around the module toStandaloneModule(schema) writes, which a
 // bundler plugin does so the runtime compiler stays out of the bundle. The
 // wrapper reproduces a default Validator's results exactly for these schemas;
-// tests/test_compiled_parity.js holds that. Declined: anything that rewrites
-// its input before the check, since `useDefaults` is on by default and the
-// module applies no defaults, and custom error messages, which the core
-// applies in a layer the wrapper does not carry. A caller must also get a
+// tests/test_compiled_parity.js holds that. Declined: custom error messages,
+// which the core applies in a layer the wrapper does not carry. A caller must also get a
 // module back from toStandaloneModule, which returns null for a schema it
 // cannot compile. The text checks are deliberately coarse: a property named
 // `default` declines too, and declining costs only the saving.
 function compiledEligible(schema) {
   if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
-  const text = JSON.stringify(schema);
-  return !text.includes('"default"') && !text.includes('"errorMessage"');
+  return !JSON.stringify(schema).includes('"errorMessage"');
+}
+
+// The schema a default Validator reads, after normalization: what
+// fromCompiled() takes, so its defaults, sorting and diagnostics follow the
+// same document the runtime does.
+function compiledSchemaFor(schema) {
+  const { Validator } = require('../index.js');
+  return new Validator(schema)._schemaObj;
 }
 
 // The module that replaces `new Validator(schema)`, or null where the
@@ -328,6 +333,7 @@ function compiledModuleFor(schema, opts) {
 
 module.exports = {
   compiledEligible,
+  compiledSchemaFor,
   compiledModuleFor,
   build,
   expandGlobs,

package/lib/compiled.js

@@ -8,11 +8,14 @@
 // objects, which come from the same rejection classes the validator core uses.
 // tests/test_compiled_parity.js holds that over the official suite.
 //
-// Only for a schema compiledEligible() accepts. Anything that rewrites its input
-// (defaults, coercion, removal), custom error messages, and every option other
-// than the defaults stay on the runtime.
+// Only for a schema compiledEligible() accepts, and with the schema
+// compiledSchemaFor() returns: the one the runtime reads, after normalization.
+// Custom error messages and every option other than the defaults stay on the
+// runtime. Defaults are applied as a default Validator applies them, before
+// any check, with the same code.
 
 const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
+const { buildDefaultsApplier } = require('./defaults');
 
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const EMPTY_ERRORS = Object.freeze([]);
@@ -41,9 +44,16 @@ class CompiledState {
 }
 
 function fromCompiled(mod, schema) {
-  const isValid = mod.isValid;
-  const errFn = mod.validate;
   const self = new CompiledState(schema);
+  const fill = buildDefaultsApplier(schema);
+  if (fill) {
+    self._mutatesInput = true;
+    self._preprocess = fill;
+  }
+  // With defaults, the document is filled in before it is checked, on every
+  // entry point, as the runtime does.
+  const isValid = fill ? (d) => { fill(d); return mod.isValid(d); } : mod.isValid;
+  const errFn = mod.validate;
   // The generated function's own result, rejected: if it says valid where the
   // verdict said no, the disagreement is reported rather than turned into an
   // acceptance, as the core does.
@@ -63,6 +73,8 @@ function fromCompiled(mod, schema) {
   return {
     validate(data) {
       if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      // The runtime returns the rich rejection directly when it rewrites input.
+      if (fill) return rich(data);
       return new LazyRejection(buildErrors, data, buildRawErrors);
     },
     isValidObject(data) {

package/lib/defaults.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// The closure pass that fills `default` values, shared by the validator core
+// and by the wrapper around a compiled module, so both fill defaults the same
+// way. The generated pass in index.js is held to this one by
+// tests/test_nested_defaults_engines.js.
+
+// Extract default values from a schema tree. Returns a function that applies
+// defaults to an object in-place (mutates), or null if no defaults exist.
+function buildDefaultsApplier(schema) {
+  if (typeof schema !== "object" || schema === null) return null;
+  const actions = [];
+  collectDefaults(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+// Write an own property. Plain assignment of a key named `__proto__` does
+// not create a property at all: it hits the Object.prototype setter and
+// rewrites the object's prototype, which is how a schema could reach
+// Object.prototype itself. defineProperty has no such special case.
+function setOwn(obj, key, val) {
+  if (key === "__proto__") {
+    Object.defineProperty(obj, key, {
+      value: val,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
+  } else {
+    obj[key] = val;
+  }
+}
+
+function collectDefaults(schema, actions, path) {
+  if (typeof schema !== "object" || schema === null) return;
+  const props = schema.properties;
+  if (!props) return;
+  for (const [key, prop] of Object.entries(props)) {
+    if (prop && typeof prop === "object" && prop.default !== undefined) {
+      const defaultVal = prop.default;
+      if (!path) {
+        actions.push((data) => {
+          if (typeof data === "object" && data !== null && !Object.hasOwn(data, key)) {
+            setOwn(data,
+              key,
+              typeof defaultVal === "object" && defaultVal !== null
+                ? JSON.parse(JSON.stringify(defaultVal))
+                : defaultVal);
+          }
+        });
+      } else {
+        const parentPath = path;
+        actions.push((data) => {
+          let target = data;
+          for (let j = 0; j < parentPath.length; j++) {
+            if (typeof target !== "object" || target === null) return;
+            // Own keys only. `target[key]` for an inherited name walks the
+            // prototype chain: a parent named `__proto__` that the instance
+            // does not carry resolved to Object.prototype, and the child
+            // defaults were written onto it, for every object in the realm.
+            if (!Object.hasOwn(target, parentPath[j])) return;
+            target = target[parentPath[j]];
+          }
+          if (
+            typeof target === "object" &&
+            target !== null &&
+            !Object.hasOwn(target, key)
+          ) {
+            setOwn(target,
+              key,
+              typeof defaultVal === "object" && defaultVal !== null
+                ? JSON.parse(JSON.stringify(defaultVal))
+                : defaultVal);
+          }
+        });
+      }
+    }
+    // Recurse into nested object schemas
+    if (prop && typeof prop === "object" && prop.properties) {
+      collectDefaults(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
+module.exports = { buildDefaultsApplier, setOwn };