ata-validator 1.48.0 → 1.50.0

package/lib/aot-impl.js

@@ -113,6 +113,9 @@ function toStandalone(validator) {
   // Also capture error function source for zero-compile standalone load
   const jsErrFn = compileToJSCodegenWithErrors(
     typeof validator._schemaObj === 'object' ? validator._schemaObj : {},
+    null,
+    null,
+    { noOrdinal: true },
   );
   const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
 
@@ -349,7 +352,10 @@ function toStandaloneModule(validator, opts) {
   const jsFn = validator._jsFn;
   if (!jsFn || !jsFn._source) return null;
   const format = (opts && opts.format) || 'esm';
-  const abortEarly = !!(opts && opts.abortEarly);
+  // A compact module (toCompactModule) carries the verdict and its schema, and
+  // takes its errors from the shared runtime at this import specifier.
+  const errorRuntime = opts && typeof opts._errorRuntime === 'string' ? opts._errorRuntime : null;
+  const abortEarly = !!(opts && opts.abortEarly) || errorRuntime !== null;
   const source = !!(opts && opts.source);
   const sourceMap = opts && opts.sourceMap ? opts.sourceMap : null;
   const schemaFile = opts && opts.schemaFile ? opts.schemaFile : null;
@@ -388,11 +394,14 @@ function toStandaloneModule(validator, opts) {
       `const _ER = function(e) { _ataStamp(e); this.valid = false; this.errors = e; };\n` +
       `${codeTableSource(onePass.keywords, onePass.formats)}const _vC = (function() {\n${onePass.core}\n})();\n`;
   } else if (!abortEarly) {
+    // A module returns the collector's errors as they are and never sorts
+    // them, so the ordinal the runtime sorts by (`_o`) has no reader there;
+    // it leaked into every error object a module reported.
     jsErrFn = compileToJSCodegenWithErrors(
       typeof validator._schemaObj === 'object' ? validator._schemaObj : {},
       null,
       validator._userFormats,
-      (source && sourceMap && schemaFile) ? { sourceMap, schemaFile, frames: sourceFrames } : null,
+      (source && sourceMap && schemaFile) ? { sourceMap, schemaFile, frames: sourceFrames, noOrdinal: true } : { noOrdinal: true },
     );
     const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
     if (errSrc && jsErrFn._errFactory) {
@@ -482,7 +491,43 @@ function toStandaloneModule(validator, opts) {
   const fmt = emitFormatDecls(jsFn._formatClosures, opts && opts.formatMode, 'const');
   const formatDecls = fmt.decls;
 
-  const validBody = onePass !== null
+  // A compact module takes the linear-time pattern engine from the runtime,
+  // which carries it anyway, instead of embedding a copy (2.9 KB gzipped,
+  // minified) in every module that has a pattern the platform RegExp does not
+  // run.
+  const usesSafeRe = errorRuntime !== null && ((jsFn && jsFn._usesSafeRe) || (jsErrFn && jsErrFn._usesSafeRe));
+  let compactCore = '';
+  if (errorRuntime !== null) {
+    const { stripAnnotations } = require('./schema-strip');
+    const { isV1Dialect } = require('./dialect');
+    const sch = typeof validator._schemaObj === 'object' ? validator._schemaObj : validator._schemaObj;
+    // Embedded as JSON text and parsed: a literal would turn a "__proto__"
+    // key into the object's prototype, and V8 reads JSON faster than an
+    // object literal of the same size.
+    const text = JSON.stringify(JSON.stringify(stripAnnotations(sch))).replace(/</g, '\\u003c');
+    const v1 = sch !== null && typeof sch === 'object' && isV1Dialect(sch);
+    // No embedded resource and no anchor anywhere (a key of that name inside
+    // a value counts too): the runtime can skip indexing the schema.
+    const flat = (() => {
+      const seen = new Set();
+      const walk = (n, root) => {
+        if (n === null || typeof n !== 'object' || seen.has(n)) return true;
+        seen.add(n);
+        if (Array.isArray(n)) return n.every((x) => walk(x, false));
+        if ('$anchor' in n || '$dynamicAnchor' in n || (!root && '$id' in n)) return false;
+        return Object.keys(n).every((k) => walk(n[k], false));
+      };
+      return walk(stripAnnotations(sch), true);
+    })();
+    const rtOpts = [v1 ? 'v1: true' : '', flat ? 'flat: true' : ''].filter(Boolean).join(', ');
+    // Nothing of it runs at import: the schema is parsed and the runtime
+    // set up on the first rejected document whose errors are read, so a
+    // module that only accepts costs no more to load than its verdict.
+    compactCore = `let _ataErrs = null;\nfunction _ataErrors(d) { if (_ataErrs === null) _ataErrs = _ataCreateErrors(JSON.parse(${text})${rtOpts ? ', { ' + rtOpts + ' }' : ''}); return _ataErrs(d); }\n`;
+  }
+  const validBody = errorRuntime !== null
+    ? 'if (_fn(data)) return VALID; const e = _ataErrors(data); return e === null ? ABORT : { valid: false, errors: e }'
+    : onePass !== null
     ? 'return _vC(data)'
     : errCore
       ? 'return _fn(data) ? VALID : { valid: false, errors: errFn(data, true).errors }'
@@ -559,7 +604,7 @@ function validateJSON(text) {
   // schema as the caller wrote it (before dialect normalization), so a build
   // can compare it against schemaHash(currentSchema) and know the module is
   // stale without embedding its own fingerprint.
-  const hashSrc = schemaHash(validator._rawSchema !== undefined ? validator._rawSchema : validator._schemaObj);
+  const hashSrc = hashOf(validator);
   // The schema hash answers "is this module built from a different schema" and
   // nothing else. Upgrading ata and not re-running the generate step leaves the
   // hash matching, so the stale module reads as current. The module cannot ask
@@ -583,11 +628,11 @@ function validateJSON(text) {
     degradedNote += '// NOTE: parse() was requested but could not be generated for this schema;\n// the module has no parse export. Validate and strip with the runtime Validator.\n';
   }
   return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit.
-// Schema is embedded; runtime has zero dependency on ata-validator.
+${errorRuntime === null ? '// Schema is embedded; runtime has zero dependency on ata-validator.' : '// Compact module: the verdict and the schema; errors come from the runtime it imports.'}
 // Re-run the build after upgrading ata: the version above is what wrote this.
 ${degradedNote}'use strict';
-${_CP_LEN_SOURCE}
-${safeRePrelude(jsFn, jsErrFn, onePass !== null && onePass.usesSafeRe ? { _usesSafeRe: true } : null)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
+${errorRuntime === null ? '' : format === 'esm' ? `import { createErrors as _ataCreateErrors${usesSafeRe ? ', compileSafe as _ataCompileSafe' : ''} } from ${JSON.stringify(errorRuntime)};\n` : `const { createErrors: _ataCreateErrors${usesSafeRe ? ', compileSafe: _ataCompileSafe' : ''} } = require(${JSON.stringify(errorRuntime)});\n`}${_CP_LEN_SOURCE}
+${errorRuntime !== null ? (usesSafeRe ? 'const __ataSafeRe = _ataCompileSafe;\n' : '') : safeRePrelude(jsFn, jsErrFn, onePass !== null && onePass.usesSafeRe ? { _usesSafeRe: true } : null)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const ABORT = Object.freeze({
   valid: false,
   errors: Object.freeze([Object.freeze({
@@ -600,11 +645,155 @@ const ABORT = Object.freeze({
 ${closureDecls}${sharedBlock}${preambleDecls}${formatDecls}const _fn = function(d) {
   ${src}
 };
-${errCore}function isValid(data) { return _fn(data); }
+${errCore}${compactCore}function isValid(data) { return _fn(data); }
 function validate(data) { ${validBody}; }
 ${parseCore}${positionsCore}${hashDecl}${exports}`;
 }
 
+// Why a validator cannot be written as a compact module, or null when it can.
+// The error runtime walks the embedded schema with the interpreted engine and
+// knows nothing the schema does not say, so anything the validator adds from
+// outside the schema keeps the module self-contained.
+// The error runtime's generator reads the library's own files with fs, and
+// runs in Node only (ata build, errorRuntimeSource). It is required through a
+// name rather than a literal so that a bundler following this module, in a
+// build of the package for a runtime without fs, does not try to bring fs
+// along: 1.49.0 bundled for such runtimes, and the generator must not break
+// that.
+const ERROR_RUNTIME_MODULE = './error-runtime';
+function loadErrorRuntime() { return require(ERROR_RUNTIME_MODULE); }
+
+// The schema hash a module stamps, once per validator: a plugin writes both
+// modules of a schema (self-contained and compact) from one validator, and
+// hashing a large schema canonically is not free.
+const _hashes = new WeakMap();
+function hashOf(validator) {
+  let h = _hashes.get(validator);
+  if (h === undefined) {
+    h = schemaHash(validator._rawSchema !== undefined ? validator._rawSchema : validator._schemaObj);
+    _hashes.set(validator, h);
+  }
+  return h;
+}
+
+// True when every $ref and $dynamicRef in the schema resolves inside it, by
+// the interpreter's own resolver.
+function hasRefKey(n, seen) {
+  if (n === null || typeof n !== 'object' || seen.has(n)) return false;
+  seen.add(n);
+  if (Array.isArray(n)) { for (const x of n) if (hasRefKey(x, seen)) return true; return false; }
+  if ('$ref' in n || '$dynamicRef' in n) return true;
+  for (const k of Object.keys(n)) if (hasRefKey(n[k], seen)) return true;
+  return false;
+}
+
+function refsResolveWithin(schema) {
+  // No reference anywhere (a key of that name inside a value counts too):
+  // nothing to resolve, and no index to build.
+  if (!hasRefKey(schema, new Set())) return true;
+  const { indexSchemas, resolveRef } = require('./interpreter-core')._refInternals;
+  let state;
+  try { state = indexSchemas(schema, null); } catch { return false; }
+  for (const [node, base] of state.nodeBase) {
+    if (node === null || typeof node !== 'object') continue;
+    for (const k of ['$ref', '$dynamicRef']) {
+      const r = node[k];
+      if (r === undefined) continue;
+      if (typeof r !== 'string') return false;
+      let hit;
+      try { hit = resolveRef(r, base, state); } catch { return false; }
+      if (hit.node === undefined) return false;
+    }
+  }
+  return true;
+}
+
+const COMPACT_OPTIONS = new Set(['engine', 'strictSchema', 'logger', 'source']);
+function compactDecline(validator) {
+  // Options are allowed by name, not refused by name: one this list does not
+  // know (assertFormat: false, baseURI, a future one) may change what the
+  // verdict means, and the runtime would not know to follow it.
+  // What the validator registers beside its schema (a meta-schema it
+  // resolves, for one) is known only once it has compiled.
+  validator._ensureCompiled();
+  const o = validator._options || {};
+  for (const k of Object.keys(o)) {
+    if (o[k] === undefined || COMPACT_OPTIONS.has(k)) continue;
+    return 'option ' + k;
+  }
+  if (validator._usesKeywords || validator._externalChecks) return 'custom keywords';
+  if (validator._userFormats && Object.keys(validator._userFormats).length) return 'custom formats';
+  if (validator._schemaMap && validator._schemaMap.size > 0) return 'schemas registered beside the root';
+  if (validator._schemaObj === null || typeof validator._schemaObj !== 'object') return 'boolean schema';
+  // The runtime has the embedded schema and nothing else: a reference that
+  // lands outside it (a meta-schema the runtime Validator resolves from its
+  // vendored copies, a schema registered later) would come back unresolved,
+  // and the errors with it. The check runs on the schema as embedded.
+  const { stripAnnotations } = require('./schema-strip');
+  if (!refsResolveWithin(stripAnnotations(validator._schemaObj))) return 'a reference outside the schema';
+  return null;
+}
+
+// A module that carries its verdict and its schema without the descriptive
+// keywords, and imports its errors from the shared runtime at `errorRuntime`
+// (written beside it by the build, see errorRuntimeSource). Null when the
+// validator cannot be written this way; the caller writes the
+// self-contained module instead.
+function toCompactModule(validator, opts) {
+  assertEmittable(validator, 'toCompactModule');
+  if (!opts || typeof opts.errorRuntime !== 'string') throw new TypeError('toCompactModule: opts.errorRuntime (the import specifier of the error runtime) is required');
+  if (compactDecline(validator) !== null) return null;
+  return toStandaloneModule(validator, { format: opts.format, formatMode: opts.formatMode, _errorRuntime: opts.errorRuntime });
+}
+
+// A schema module: the schema without its descriptive keywords and a few lines
+// that hand it to the runtime at `opts.runtime`, which answers both the
+// verdict and the errors with the interpreted engine. Smaller and quicker to
+// load than generated code, slower per check once warm (about five times on
+// SchemaStore documents). Answers as toCompactModule's module does. Null
+// where toCompactModule would be null.
+function toSchemaModule(validator, opts) {
+  assertEmittable(validator, 'toSchemaModule');
+  if (!opts || typeof opts.runtime !== 'string') throw new TypeError('toSchemaModule: opts.runtime (the import specifier of the schema runtime) is required');
+  if (compactDecline(validator) !== null) return null;
+  const format = opts.format || 'esm';
+  const { stripAnnotations } = require('./schema-strip');
+  const { isV1Dialect } = require('./dialect');
+  const sch = validator._schemaObj;
+  const stripped = stripAnnotations(sch);
+  const text = JSON.stringify(JSON.stringify(stripped)).replace(/</g, '\\u003c');
+  const seen = new Set();
+  const flatWalk = (n, root) => {
+    if (n === null || typeof n !== 'object' || seen.has(n)) return true;
+    seen.add(n);
+    if (Array.isArray(n)) return n.every((x) => flatWalk(x, false));
+    if ('$anchor' in n || '$dynamicAnchor' in n || (!root && '$id' in n)) return false;
+    return Object.keys(n).every((k) => flatWalk(n[k], false));
+  };
+  const rtOpts = [isV1Dialect(sch) ? 'v1: true' : '', flatWalk(stripped, true) ? 'flat: true' : ''].filter(Boolean).join(', ');
+  const hashSrc = hashOf(validator);
+  const spec = JSON.stringify(opts.runtime);
+  const imp = format === 'esm'
+    ? `import { createValidator as _ataCreateValidator } from ${spec};\n`
+    : `const { createValidator: _ataCreateValidator } = require(${spec});\n`;
+  const exp = format === 'esm'
+    ? 'export { validate, isValid, schemaHash, ataVersion };\nexport default { validate, isValid, schemaHash, ataVersion };\n'
+    : 'module.exports = { validate, isValid, schemaHash, ataVersion };\nmodule.exports.default = module.exports;\n';
+  return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit.
+// Schema module: the schema; the verdict and the errors come from the runtime it imports.
+// Re-run the build after upgrading ata: the version above is what wrote this.
+'use strict';
+${imp}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
+const ABORT = Object.freeze({ valid: false, errors: Object.freeze([Object.freeze({ code: 'ATA9000', message: 'validation failed', keyword: '__abort_early__', path: '' })]) });
+let _ataV = null;
+function _ataGet() { return _ataV !== null ? _ataV : (_ataV = _ataCreateValidator(JSON.parse(${text})${rtOpts ? ', { ' + rtOpts + ' }' : ''})); }
+function isValid(data) { return _ataGet().isValid(data); }
+function validate(data) { const v = _ataGet(); if (v.isValid(data)) return VALID; const e = v.errors(data); return e === null ? ABORT : { valid: false, errors: e }; }
+const schemaHash = ${JSON.stringify(hashSrc)};
+const ataVersion = ${JSON.stringify(ATA_VERSION)};
+${exp}`;
+}
+
 // Bundle multiple validators into a single JS file for fast startup.
 // Usage:
 //   const bundle = Validator.bundle([schema1, schema2, ...]);
@@ -665,6 +854,7 @@ function bundleStandalone(Validator, schemas, opts) {
       v._schemaObj,
       v._schemaMap,
       v._userFormats,
+      { noOrdinal: true },
     );
     if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
     return { v, jsFn, jsErrFn };
@@ -757,6 +947,7 @@ function bundleCompact(Validator, schemas, opts) {
       v._schemaObj,
       v._schemaMap,
       v._userFormats,
+      { noOrdinal: true },
     );
     if (jsFn._usesSafeRe || (jsErrFn && jsErrFn._usesSafeRe)) bundleUsesSafeRe = true;
     // Hoisted anyOf/oneOf branch helpers (e.g. `_af1_b0`) must travel with the
@@ -917,6 +1108,23 @@ const htmlSafeResult = (fn) => function () { return htmlSafe(fn.apply(this, argu
 module.exports = {
   toStandalone: htmlSafeResult(toStandalone),
   toStandaloneModule: htmlSafeResult(toStandaloneModule),
+  toCompactModule: htmlSafeResult(toCompactModule),
+  toSchemaModule: htmlSafeResult(toSchemaModule),
+  compactDecline,
+  // `schemas`: the validators (or schemas) whose compact modules will import
+  // this runtime; parts none of them needs are left out. Omitted, the
+  // runtime carries every part.
+  // `schemaMode`: the runtime schema modules import, which also answers the
+  // verdict (createValidator).
+  errorRuntimeSource: htmlSafeResult((format, schemas, schemaMode) => {
+    const er = loadErrorRuntime();
+    if (!Array.isArray(schemas)) return er.errorRuntimeSource(format, ATA_VERSION, undefined, !!schemaMode);
+    const { stripAnnotations } = require('./schema-strip');
+    const embedded = schemas.map((x) => stripAnnotations(x && typeof x === 'object' && x._schemaObj !== undefined ? x._schemaObj : x));
+    const features = er.runtimeFeatures(embedded);
+    for (const x of schemas) if (x && x._jsFn && x._jsFn._usesSafeRe) features['safe-regex'] = true;
+    return er.errorRuntimeSource(format, ATA_VERSION, features, !!schemaMode);
+  }),
   bundle: htmlSafeResult(bundle),
   bundleStandalone: htmlSafeResult(bundleStandalone),
   bundleCompact: htmlSafeResult(bundleCompact),