ata-validator 1.60.0 → 1.61.1

package/lib/aot-build.js

@@ -202,7 +202,29 @@ function pruneRegistry(roots, byId) {
   return out;
 }
 
+function bunTargetPath (output) {
+  const ext = path.extname(output);
+  return output.slice(0, output.length - ext.length) + '.bun.ts';
+}
+
 async function build(opts) {
+  // `--target bun`: every module written for JavaScriptCore, the plain ones
+  // included, since the executable the target is for runs on it.
+  const { setTargetEngine } = require('./js-compiler');
+  const prevEngine = setTargetEngine(opts.target === 'bun' ? 'jsc-aot' : null);
+  // An executable compiled ahead of time pays no bundle size and answers
+  // rejections: the one-pass error function (3.6x cheaper on a rejection, 20%
+  // larger gzipped) is the default there, and schema-source frames, which it
+  // does not carry, are off unless asked for.
+  if (opts.target === 'bun') opts = { ...opts, onePass: opts.onePass === undefined ? true : opts.onePass, source: opts.source === true ? true : false };
+  try {
+    return await buildWith(opts);
+  } finally {
+    setTargetEngine(prevEngine);
+  }
+}
+
+async function buildWith(opts) {
   const globs = opts.globs || [];
   if (globs.length === 0) throw new Error('build: at least one glob required');
   const format = opts.format || 'esm';
@@ -226,6 +248,10 @@ async function build(opts) {
 
   const compiled = [];
   const cached = [];
+  // --target bun: the .bun.ts written beside a module, and the schemas whose
+  // rules a type cannot carry.
+  const bunTargets = [];
+  const bunDeclined = [];
   const skipped = [];
   const failed = [];
   const warnings = [];
@@ -345,7 +371,10 @@ async function build(opts) {
         // the registry is put together from such modules: always rebuilt.
         !cacheEntry.usesSiblings &&
         fs.existsSync(output) &&
-        cacheEntry.outputHash === hashContent(fs.readFileSync(output))
+        cacheEntry.outputHash === hashContent(fs.readFileSync(output)) &&
+        // The Bun target is written beside the module; when it is asked for
+        // and missing, the module is rebuilt so that it gets written.
+        (opts.target !== 'bun' || fs.existsSync(bunTargetPath(output)))
       );
       if (opts.check) {
         if (fresh) cached.push({ input, output });
@@ -460,12 +489,25 @@ async function build(opts) {
         continue;
       }
       compiled.push({ input, output, bytes: outBytes, gzipBytes: gzBytes, errors: e.mode });
+      const stem = path.basename(input, path.extname(input)).replace(/\.schema$/, '');
+      const typeName = stem
+        .replace(/[^A-Za-z0-9_]/g, '_')
+        .replace(/^([a-z])/, (m) => m.toUpperCase()) || 'Data';
+      if (opts.target === 'bun') {
+        const { writeBunTarget, Declined } = require('./bun-target');
+        try {
+          const w = writeBunTarget({ schema: e.schema, input, output, typeName });
+          bunTargets.push({ input, output: w.bunPath, definitions: w.definitions });
+        } catch (err) {
+          if (!(err instanceof Declined)) throw err;
+          // No type can be written; the plain module stands alone.
+          const reason = `--target bun: ${err.message}; the plain module stands alone`;
+          if (opts.strict) { failed.push({ input, error: reason }); continue; }
+          bunDeclined.push({ input, reason });
+        }
+      }
       if (opts.types !== false) {
         const { toTypeScript } = require('./ts-gen');
-        const stem = path.basename(input, path.extname(input)).replace(/\.schema$/, '');
-        const typeName = stem
-          .replace(/[^A-Za-z0-9_]/g, '_')
-          .replace(/^([a-z])/, (m) => m.toUpperCase()) || 'Data';
         const dts = toTypeScript(e.schema, { name: typeName, applyDefaults: /\nfunction applyDefaults\(/.test(src) });
         const ext = path.extname(output);
         const dtsExt = ext === '.mjs' ? '.d.mts'
@@ -514,7 +556,7 @@ async function build(opts) {
   // module, whose errors come from the runtime. Only the written one counts.
   const fromRuntime = new Set(entries.filter((e) => e.mode !== 'inline').map((e) => e.input));
   const kept = warnings.filter((w) => !(w.kind === 'error-detail' && fromRuntime.has(w.input)));
-  return { compiled, cached, skipped, failed, warnings: kept, runtime: runtimeReport };
+  return { compiled, cached, skipped, failed, warnings: kept, runtime: runtimeReport, bunTargets, bunDeclined };
 }
 
 async function watch(opts, onReport) {
@@ -647,6 +689,18 @@ function compiledModuleFor(schema, opts) {
   try {
     src = aot.toStandaloneModule(validatorFor(schema), {
       format: (opts && opts.format) || 'esm',
+      // The one-pass error function where the caller asks (a plugin writing
+      // for a Bun executable): 3.6x cheaper on a rejection, 20% larger gzipped.
+      onePass: opts && opts.onePass === true ? true : undefined,
+      source: opts && (opts.onePass === true || opts.plainErrors === true) ? false : undefined,
+      // Errors in the runtime's `richErrors: false` shape, for
+      // ata-validator/compiled-plain, which hands them out as they are.
+      plainErrors: !!(opts && opts.plainErrors === true),
+      // `verdictOnly`: the module for a reader that only ever calls isValid
+      // (a bundler plugin's verdict wrappers). Its validate() hands out the
+      // abort-early stub, so the error collector, never called there, is not
+      // written: 954 to 539 bytes gzipped on a one-field object.
+      abortEarly: !!(opts && opts.verdictOnly === true),
       // Errors in the runtime's order, for a reader that does not sort them
       // itself (a form resolver); fromCompiled sorts, so a plugin putting
       // that wrapper around the module leaves it off.
@@ -664,7 +718,28 @@ function compiledModuleFor(schema, opts) {
 // not export this, and a plugin should then replace only calls without options.
 const { COMPILED_OPTIONS: compiledOptions } = require('./compiled');
 
+// For a build plugin: the Bun target (lib/bun-target.js) and the verification
+// (lib/verify.js), loaded on first use.
+const bunTarget = {
+  get schemaToBunType () { return require('./bun-target').schemaToBunType },
+  get toBunModule () { return require('./bun-target').toBunModule },
+  get writeBunTarget () { return require('./bun-target').writeBunTarget },
+  get Declined () { return require('./bun-target').Declined },
+  // The generated code's target engine (lib/js-compiler): a plugin that
+  // writes for a Bun executable compiled ahead of time sets 'jsc-aot'.
+  setTargetEngine (engine) { return require('./js-compiler').setTargetEngine(engine) },
+}
+const verify = {
+  get verifyOne () { return require('./verify').verifyOne },
+  get verifySource () { return require('./verify').verifySource },
+  get generate () { return require('./verify').generate },
+  get renderReport () { return require('./verify').renderReport },
+  get ok () { return require('./verify').ok },
+}
+
 module.exports = {
+  bunTarget,
+  verify,
   compiledOptions,
   compiledEligible,
   compiledSchemaFor,

package/lib/aot-impl.js

@@ -367,7 +367,7 @@ function defaultsDecl(validator) {
   if (defaults.buildDefaultsApplier(schema) === null) return '';
   const embedded = require('./schema-strip').stripAnnotationsKeepingDefaults(schema);
   const text = JSON.stringify(JSON.stringify(embedded)).replace(/</g, '\\u003c');
-  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${require(AOT_ORDER_MODULE).take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
+  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${loadAotOrder().take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
     `let _ataFill;\nfunction applyDefaults(d) { (_ataFill || (_ataFill = _ataDefaults(JSON.parse(${text}))))(d); }\n`;
 }
 
@@ -430,7 +430,12 @@ function toStandaloneModule(validator, opts) {
   // documents against large schemas asks for it.
   let onePass = null;
   let ordered = false;
-  const wantOnePass = opts && opts.onePass === true ? 'always' : (opts && (opts.onePass === false || opts.noOnePass)) ? 'never' : 'auto';
+  // `plainErrors`: the errors in the runtime's `richErrors: false` shape, as
+  // the one-pass program writes them before codes and links are stamped on.
+  // A wrapper that hands them out as they are (ata-validator/compiled-plain)
+  // then carries no error pipeline of its own.
+  const plainErrors = !!(opts && opts.plainErrors === true);
+  const wantOnePass = plainErrors || (opts && opts.onePass === true) ? 'always' : (opts && (opts.onePass === false || opts.noOnePass)) ? 'never' : 'auto';
   // Asked for explicitly, the one-pass function wins over schema-source
   // frames, which `ata compile` writes by default outside production; the
   // caller is told, since it asked for both.
@@ -445,7 +450,10 @@ function toStandaloneModule(validator, opts) {
     }
     if (wantOnePass === 'always' || errLen === 0) onePass = onePassCore(validator, opts);
   }
-  if (onePass !== null) {
+  if (onePass !== null && plainErrors) {
+    errCore = `const _ER = function(e) { this.valid = false; this.errors = e; };\n` +
+      `const _vC = (function() {\n${onePass.core}\n})();\n`;
+  } else if (onePass !== null) {
     errCore = `function _ataStamp(e) { for (let i = 0; i < e.length; i++) { const x = e[i]; if (x.code === undefined) { const c = x.keyword === 'required' && typeof x.schemaPath === 'string' && x.schemaPath.endsWith('/dependentRequired') ? 'ATA7005' : _ataCode(x.keyword, x.params && x.params.format); if (c !== null) { x.code = c; x.docUrl = 'https://ata-validator.com/e/' + c; } } else if (x.docUrl === undefined) x.docUrl = 'https://ata-validator.com/e/' + x.code; if (x.branchErrors !== undefined) _ataStamp(x.branchErrors); } }\n` +
       `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`;
@@ -458,7 +466,7 @@ function toStandaloneModule(validator, opts) {
     // sorts by each error site's ordinal, the collector writes it (`_o`).
     const schemaForErrors = typeof validator._schemaObj === 'object' ? validator._schemaObj : {};
     ordered = !!(opts && opts.order === true);
-    const noOrdinal = !ordered || !require(AOT_ORDER_MODULE).wantsOrdinals(schemaForErrors);
+    const noOrdinal = !ordered || !loadAotOrder().wantsOrdinals(schemaForErrors);
     jsErrFn = compileToJSCodegenWithErrors(
       schemaForErrors,
       null,
@@ -600,7 +608,7 @@ function toStandaloneModule(validator, opts) {
     compactCore = `let _ataErrs = null;\nfunction _ataErrors(d) { if (_ataErrs === null) _ataErrs = _ataCreateErrors(JSON.parse(${text})${rtOpts ? ', { ' + rtOpts + ' }' : ''}); return _ataErrs(d); }\n`;
   }
   const orderDecl = errCore && ordered && errorRuntime === null && onePass === null
-    ? require(AOT_ORDER_MODULE).orderDecl(validator._schemaObj)
+    ? loadAotOrder().orderDecl(validator._schemaObj)
     : '';
   // Asked for and not given: stub errors, the one-pass function, or no error
   // code generated. The caller is told rather than handed the collector's
@@ -736,20 +744,15 @@ function validate(data) { ${pre.call}${validBody}; }
 ${parseCore}${positionsCore}${fillDecl}${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';
-// Reads the library's files too, at build time (see lib/aot-order.js).
-const AOT_ORDER_MODULE = './aot-order';
-function loadErrorRuntime() { return require(ERROR_RUNTIME_MODULE); }
+// The error runtime and the order helpers are required by their literal
+// names: an executable compiled ahead of time (Bun) loads a module from a
+// computed path by throwing, and warns about every such require at build
+// time. Both modules read the library's own files with fs at build time;
+// a bundle for a runtime without fs is kept away from lib/aot-order.js by
+// the package's `browser` field, and lib/error-runtime.js loads fs only in
+// the functions that read files.
+function loadErrorRuntime() { return require('./error-runtime'); }
+function loadAotOrder() { return require('./aot-order'); }
 
 // 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
@@ -973,7 +976,7 @@ function bundleStandalone(Validator, schemas, opts) {
     v._ensureCompiled();
     const jsFn = v._jsFn;
     if (!jsFn || !jsFn._hybridSource) return null;
-    const noOrdinal = !ordered || !require(AOT_ORDER_MODULE).wantsOrdinals(v._schemaObj);
+    const noOrdinal = !ordered || !loadAotOrder().wantsOrdinals(v._schemaObj);
     // The schema the validator compiled, not the one the caller passed. They
     // differ whenever anything prepared the schema: draft-07 normalization,
     // `format` removed under assertFormat: false, keywords outside the
@@ -1040,7 +1043,7 @@ function bundleStandalone(Validator, schemas, opts) {
     // In order: the collector's errors sorted as the runtime sorts them.
     const hasErr = !!(jsErrFn && jsErrFn._errSource);
     const errDecl = ordered && hasErr
-      ? `${require(AOT_ORDER_MODULE).orderDecl(v._schemaObj)}var E=function(d){var r=(function(d){var _all=true;${errBody}})(d);return r&&r.errors?{valid:false,errors:_ataOrder(r.errors)}:r};`
+      ? `${loadAotOrder().orderDecl(v._schemaObj)}var E=function(d){var r=(function(d){var _all=true;${errBody}})(d);return r&&r.errors?{valid:false,errors:_ataOrder(r.errors)}:r};`
       : `var E=function(d){var _all=true;${errBody}};`;
     if (opts && opts.verbose) {
       // Embed the schema and a small resolver so errors carry parentSchema.