ata-validator 1.6.2 → 1.7.1

package/lib/aot.js

@@ -21,7 +21,7 @@ const SAFE_REGEX_SOURCE = require('./safe-regex-source');
 const _CP_LEN_SOURCE = `function _cpLen(s) {
   const len = s.length;
   for (let i = 0; i < len; i++) {
-    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
+    if (((s.charCodeAt(i) - 0xD800) >>> 0) < 0x400) {
       let n = 0; for (const _ of s) n++; return n;
     }
   }
@@ -98,6 +98,48 @@ module.exports = { boolFn, hybridFactory, errFn };
 //
 // format: 'esm' | 'cjs'. Default 'esm'.
 // abortEarly: if true, invalid result is a shared stub; smaller output.
+
+// Custom format functions in standalone output.
+//
+// 'embed' (default) writes each function's source into the module through
+// Function#toString. That only works for a plain function: one that closes
+// over nothing and is not rewritten by a coverage or transpile step (istanbul
+// injects `cov_` counters; a bundler may hoist helpers). The check below
+// rejects those at build time with a named error instead of emitting a module
+// that throws on first use.
+//
+// 'inject' writes no function source. The module exports `setFormats(map)`
+// and each format is looked up from that registry when a value is checked,
+// so the caller supplies the functions at load time.
+function emitFormatDecls(closures, mode, declKW) {
+  if (!closures || closures.length === 0) return { decls: '', exportsSetFormats: false };
+  if (mode === 'inject') {
+    let out = `${declKW} __formats = Object.create(null);\n`;
+    out += `function setFormats(map) { for (const k in map) __formats[k] = map[k]; }\n`;
+    for (const { name, format } of closures) {
+      const key = JSON.stringify(format === null ? name.slice(4) : format);
+      out += `${declKW} ${name} = function (v) { const f = __formats[${key}]; if (typeof f !== 'function') throw new Error('ata: format ' + ${key} + ' is not registered; call setFormats({ [' + ${key} + ']: fn }) before validating'); return f(v); };\n`;
+    }
+    return { decls: out, exportsSetFormats: true };
+  }
+  let out = '';
+  for (const { name, fn, format } of closures) {
+    const src = fn.toString();
+    const label = format === null ? name : format;
+    if (/\bcov_[A-Za-z0-9_$]+\b/.test(src)) {
+      throw new Error(`ata: custom format "${label}" is instrumented for coverage and cannot be embedded; use { formatMode: 'inject' } and register it with setFormats() at load time`);
+    }
+    try {
+      // eslint-disable-next-line no-new-func
+      new Function('return (' + src + ')');
+    } catch {
+      throw new Error(`ata: custom format "${label}" has no standalone source (a bound function, a class method, or a native); use { formatMode: 'inject' } and register it with setFormats() at load time`);
+    }
+    out += `${declKW} ${name} = ${src};\n`;
+  }
+  return { decls: out, exportsSetFormats: false };
+}
+
 function toStandaloneModule(validator, opts) {
   validator._ensureCompiled();
   const jsFn = validator._jsFn;
@@ -170,20 +212,17 @@ function toStandaloneModule(validator, opts) {
   // User-supplied format functions are referenced as _uf_<name> by both the
   // boolean (_fn) and error (errFn) bodies. Embed them via Function#toString
   // so the standalone module stays self-contained.
-  let formatDecls = '';
-  if (jsFn._formatClosures && jsFn._formatClosures.length > 0) {
-    formatDecls = jsFn._formatClosures
-      .map(({ name, fn }) => `const ${name} = ${fn.toString()};`)
-      .join('\n') + '\n';
-  }
+  const fmt = emitFormatDecls(jsFn._formatClosures, opts && opts.formatMode, 'const');
+  const formatDecls = fmt.decls;
 
   const validBody = errCore
     ? 'return _fn(data) ? VALID : { valid: false, errors: errFn(data, true).errors }'
     : 'return _fn(data) ? VALID : ABORT';
 
+  const names = fmt.exportsSetFormats ? 'validate, isValid, setFormats' : 'validate, isValid';
   const exports = format === 'esm'
-    ? `export { validate, isValid };\nexport default { validate, isValid };\n`
-    : `module.exports = { validate, isValid };\nmodule.exports.default = module.exports;\n`;
+    ? `export { ${names} };\nexport default { ${names} };\n`
+    : `module.exports = { ${names} };\nmodule.exports.default = module.exports;\n`;
 
   return `// Auto-generated by ata-validator — do not edit.
 // Schema is embedded; runtime has zero dependency on ata-validator.
@@ -240,6 +279,7 @@ function bundleStandalone(Validator, schemas, opts) {
   const format = (opts && opts.format) || 'cjs';
   const R = 'Object.freeze({valid:true,errors:Object.freeze([])})';
   let bundleUsesSafeRe = false;
+  let bundleInjects = false;
   const fns = schemas.map((schema) => {
     const v = new Validator(schema, bundleOpts);
     v._ensureCompiled();
@@ -255,12 +295,13 @@ function bundleStandalone(Validator, schemas, opts) {
       jsErrFn && jsErrFn._errSource
         ? jsErrFn._errSource
         : "return{valid:false,errors:[{code:'error',path:'',message:'validation failed'}]}";
-    // Serialize custom format closures so the bundle has no runtime dep on ata.
+    // Custom format closures: embedded, or bound to the bundle-level
+    // registry when opts.formats is 'inject'.
     let preamble = '';
     if (jsFn._formatClosures) {
-      preamble = jsFn._formatClosures
-        .map(({ name, fn }) => `var ${name}=${fn.toString()};`)
-        .join('\n');
+      const f = emitFormatDecls(jsFn._formatClosures, opts && opts.formatMode, 'var');
+      preamble = f.decls.replace(/^var __formats = [^\n]*\n|^function setFormats[^\n]*\n/gm, '');
+      if (f.exportsSetFormats) bundleInjects = true;
     }
     // Include hoisted anyOf/oneOf branch helpers (e.g. `_af1_b0`) so the
     // bundle output is self-contained. `toStandalone` emits this same source
@@ -277,10 +318,15 @@ function bundleStandalone(Validator, schemas, opts) {
   });
   const arr = `[${fns.join(',')}]`;
   const safeEmbed = bundleUsesSafeRe ? getSafeRegexEmbed() + '\n' : '';
+  const registry = bundleInjects
+    ? `var __formats=Object.create(null);\nfunction setFormats(map){for(var k in map)__formats[k]=map[k]}\n`
+    : '';
   if (format === 'esm') {
-    return `// Auto-generated by ata-validator — do not edit\n${safeEmbed}const R=${R};\nconst validators=${arr};\nexport default validators;\nexport { validators };\n`;
+    const extra = bundleInjects ? 'export { validators, setFormats };' : 'export { validators };';
+    return `// Auto-generated by ata-validator — do not edit\n${safeEmbed}${registry}const R=${R};\nconst validators=${arr};\nexport default validators;\n${extra}\n`;
   }
-  return `'use strict';\n${safeEmbed}var R=${R};\nmodule.exports=[${fns.join(',')}];\n`;
+  const attach = bundleInjects ? 'module.exports.setFormats=setFormats;\n' : '';
+  return `'use strict';\n${safeEmbed}${registry}var R=${R};\nmodule.exports=[${fns.join(',')}];\n${attach}`;
 }
 
 // Compact bundle: deduplicated code. Shared template functions + per-schema params.
@@ -355,14 +401,17 @@ function bundleCompact(Validator, schemas, opts) {
   // bodies. Collect them across all schemas (deduped by name) and embed via
   // Function#toString so the bundle stays self-contained.
   const fmtSeen = new Set();
+  const fmtAll = [];
   for (const e of entries) {
     if (!e || !e.fmt) continue;
-    for (const { name, fn } of e.fmt) {
-      if (fmtSeen.has(name)) continue;
-      fmtSeen.add(name);
-      out += `${declKW} ${name}=${fn.toString()};\n`;
+    for (const entry of e.fmt) {
+      if (fmtSeen.has(entry.name)) continue;
+      fmtSeen.add(entry.name);
+      fmtAll.push(entry);
     }
   }
+  const fmtOut = emitFormatDecls(fmtAll, opts && opts.formatMode, declKW);
+  out += fmtOut.decls;
 
   // Shared hybrid factories
   out += `${declKW} H=[\n`;
@@ -385,9 +434,10 @@ function bundleCompact(Validator, schemas, opts) {
     })
     .join(',');
   if (isEsm) {
-    out += `const validators=[${arrBody}];\nexport default validators;\nexport { validators };\n`;
+    out += `const validators=[${arrBody}];\nexport default validators;\nexport { validators${fmtOut.exportsSetFormats ? ', setFormats' : ''} };\n`;
   } else {
     out += `module.exports=[${arrBody}];\n`;
+    if (fmtOut.exportsSetFormats) out += 'module.exports.setFormats=setFormats;\n';
   }
 
   return out;

package/lib/buffer-gate.js

@@ -0,0 +1,132 @@
+'use strict';
+
+// The buffer APIs (isValid, countValid, batchIsValid, isValidNDJSON,
+// isValidParallel, isValidPrepadded, and isValidJSON above the simdjson
+// threshold) answer from the native engine's own walker, which is not the
+// engine validate() uses. Measured over the official suite, the two disagreed
+// on 245 of 2222 cases, and 195 of those were the native walker accepting a
+// document validate() rejects. A buffer API that is faster and sometimes
+// wrong in the accepting direction is not a fast path, it is a hole.
+//
+// This module decides, once per schema, whether the native walker can be
+// trusted for it. When it cannot, the buffer APIs are replaced with versions
+// that parse the bytes and call validate(), so every entry point gives the
+// same verdict. The list below is the set of shapes where the suite showed
+// the walker disagreeing, each with the reason. It is deliberately a list of
+// shapes rather than a count: a new disagreement is a new entry here, with
+// tests/test_buffer_path_parity.js holding the total at zero.
+
+// Keywords the native walker does not implement, or implements differently
+// enough to disagree on the suite.
+const UNSUPPORTED_KEYWORDS = new Set([
+  'contains', 'minContains', 'maxContains',
+  'unevaluatedProperties', 'unevaluatedItems',
+  'dependencies', 'dependentSchemas', 'dependentRequired',
+  'propertyNames', 'patternProperties',
+]);
+
+// Formats the native checkers answer differently from the JS ones.
+const DIVERGENT_FORMATS = new Set(['hostname', 'date-time', 'time', 'uri-reference', 'duration']);
+
+const SUBSCHEMA_MAPS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas', 'dependencies'];
+const SUBSCHEMA_NODES = [
+  'items', 'additionalItems', 'additionalProperties', 'contains', 'propertyNames', 'not',
+  'if', 'then', 'else', 'unevaluatedProperties', 'unevaluatedItems',
+  'allOf', 'anyOf', 'oneOf', 'prefixItems',
+];
+
+function walk(schema, depth) {
+  if (schema === true || schema === false) {
+    // A boolean root is answered wrong by the walker; nested booleans are
+    // handled where they appear (items and prefixItems below).
+    return depth === 0;
+  }
+  if (schema === null || typeof schema !== 'object') return false;
+  if (Array.isArray(schema)) {
+    for (const s of schema) if (walk(s, depth + 1)) return true;
+    return false;
+  }
+  for (const key of Object.keys(schema)) {
+    const v = schema[key];
+    if (UNSUPPORTED_KEYWORDS.has(key)) return true;
+    // Cross-document references: the native engine has no registry of
+    // external schemas, and embedded $id changes the base URI in ways its
+    // resolver gets wrong.
+    if (key === '$ref' && typeof v === 'string' && !v.startsWith('#')) return true;
+    if (key === '$id' && depth > 0) return true;
+    // An empty enum rejects everything; the walker accepts everything.
+    if (key === 'enum' && Array.isArray(v) && v.length === 0) return true;
+    if (key === 'format' && DIVERGENT_FORMATS.has(v)) return true;
+    // Unicode property escapes: RE2 cannot parse them and the walker then
+    // skips the pattern instead of failing.
+    if (key === 'pattern' && typeof v === 'string' && /\\[pP]\{/.test(v)) return true;
+    // Tuple forms: prefixItems and the draft-07 array form of items are
+    // checked against the wrong positions by the walker.
+    if (key === 'prefixItems') return true;
+    if ((key === 'items' || key === 'additionalItems') && (typeof v === 'boolean' || Array.isArray(v))) return true;
+
+    if (SUBSCHEMA_MAPS.includes(key)) {
+      if (v && typeof v === 'object' && !Array.isArray(v)) {
+        for (const k of Object.keys(v)) if (walk(v[k], depth + 1)) return true;
+      }
+    } else if (SUBSCHEMA_NODES.includes(key)) {
+      if (walk(v, depth + 1)) return true;
+    }
+  }
+  return false;
+}
+
+// True when the buffer APIs must answer through validate() for this schema.
+function bufferNeedsSlowPath(schema, schemaMap) {
+  if (walk(schema, 0)) return true;
+  if (schemaMap && schemaMap.size > 0) {
+    for (const s of schemaMap.values()) if (walk(s, 1)) return true;
+  }
+  return false;
+}
+
+function toText(input, name) {
+  if (typeof input === 'string') return input;
+  if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString('utf8');
+  throw new TypeError(`${name}() requires a Buffer, Uint8Array, or string. For parsed objects, use isValidObject().`);
+}
+
+// Replaces the instance's buffer APIs with versions that parse and call
+// validate(). Installed after compilation, so `validator.validate` is final.
+function installSlowBufferApis(validator) {
+  const isValidText = (text) => {
+    let value;
+    try { value = JSON.parse(text); } catch { return false; }
+    return validator.validate(value).valid;
+  };
+  validator.isValid = (input) => isValidText(toText(input, 'isValid'));
+  validator.isValidJSON = (jsonStr) => isValidText(jsonStr);
+  validator.isValidPrepadded = (paddedBuffer, jsonLength) =>
+    isValidText(Buffer.from(paddedBuffer.buffer, paddedBuffer.byteOffset, jsonLength).toString('utf8'));
+  const ndjson = (input, name) => {
+    const lines = toText(input, name).split('\n');
+    const out = [];
+    for (const line of lines) {
+      if (line === '') continue; // the native loop skips zero-length lines only
+      out.push(isValidText(line));
+    }
+    return out;
+  };
+  validator.isValidNDJSON = (input) => ndjson(input, 'isValidNDJSON');
+  validator.isValidParallel = (input) => ndjson(input, 'isValidParallel');
+  validator.countValid = (input) => {
+    let n = 0;
+    for (const ok of ndjson(input, 'countValid')) if (ok) n++;
+    return n;
+  };
+  validator.batchIsValid = (buffers) => {
+    let n = 0;
+    for (const b of buffers) {
+      if (!(b instanceof Uint8Array)) throw new TypeError('batchIsValid() requires Buffer or Uint8Array elements');
+      if (isValidText(toText(b, 'batchIsValid'))) n++;
+    }
+    return n;
+  };
+}
+
+module.exports = { bufferNeedsSlowPath, installSlowBufferApis };

package/lib/draft7.js

@@ -9,15 +9,37 @@ function isDraft7(schema) {
   return !!(schema && schema.$schema && DRAFT7_SCHEMAS.has(schema.$schema))
 }
 
-function normalizeDraft7(schema) {
-  if (!isDraft7(schema)) return schema
+// `force` applies the draft-07 rules to a document that declares no dialect
+// of its own, which is how a retrieved schema inherits the root's draft.
+function normalizeDraft7(schema, force) {
+  if (!force && !isDraft7(schema)) return schema
   _normalize(schema)
   return schema
 }
 
+// Keywords that may sit next to `$ref` in draft-07 without being applied:
+// definitions are addressable by pointer, annotations are inert.
+const REF_SIBLINGS_KEPT = new Set(['$ref', '$defs', 'definitions', '$schema', '$comment', 'title', 'description', 'examples', 'default', 'readOnly', 'writeOnly'])
+
 function _normalize(schema) {
   if (typeof schema !== 'object' || schema === null) return
 
+  // In draft-07 an object with `$ref` is that reference and nothing else:
+  // sibling keywords, `$id` included, are ignored. Dropping them here gives
+  // every engine the same reading without each having to know the draft.
+  if (typeof schema.$ref === 'string') {
+    for (const key of Object.keys(schema)) {
+      if (!REF_SIBLINGS_KEPT.has(key)) delete schema[key]
+    }
+  }
+
+  // A fragment-only `$id` is a plain-name anchor in draft-07; 2020-12 spells
+  // it `$anchor`, which every engine already resolves.
+  if (typeof schema.$id === 'string' && /^#[A-Za-z][A-Za-z0-9_.:-]*$/.test(schema.$id)) {
+    if (schema.$anchor === undefined) schema.$anchor = schema.$id.slice(1)
+    delete schema.$id
+  }
+
   // definitions → $defs
   if (schema.definitions && !schema.$defs) {
     schema.$defs = schema.definitions