ata-validator 1.48.0 → 1.50.0

package/lib/aot-build.js

@@ -87,19 +87,102 @@ function hashContent(buf) {
   return crypto.createHash('sha256').update(buf).digest('hex').slice(0, 32);
 }
 
+// Where the shared error runtime goes: the output directory when there is
+// one, otherwise the deepest directory that holds every output.
+function runtimePathFor(outputs, opts, format) {
+  const name = 'ata-errors' + (format === 'cjs' ? '.cjs' : '.mjs');
+  if (opts.outDir) return path.join(opts.outDir, name);
+  let dir = path.resolve(path.dirname(outputs[0]));
+  for (const o of outputs) {
+    const d = path.resolve(path.dirname(o));
+    while (dir !== d && !d.startsWith(dir + path.sep)) dir = path.dirname(dir);
+  }
+  return path.join(dir, name);
+}
+
+function importSpecifier(fromFile, toFile) {
+  let rel = path.relative(path.dirname(path.resolve(fromFile)), path.resolve(toFile)).split(path.sep).join('/');
+  if (!rel.startsWith('.')) rel = './' + rel;
+  return rel;
+}
+
+const RUNTIME_PLACEHOLDER = '__ATA_ERROR_RUNTIME__';
+const ERRORS_MODES = new Set(['auto', 'inline', 'shared']);
+
 async function build(opts) {
   const globs = opts.globs || [];
   if (globs.length === 0) throw new Error('build: at least one glob required');
   const format = opts.format || 'esm';
+  const errorsMode = opts.errors || 'auto';
+  if (!ERRORS_MODES.has(errorsMode)) throw new Error(`build: errors must be auto, inline or shared (got "${errorsMode}")`);
   const inputs = await expandGlobs(globs);
   const cache = readCache(opts.cacheFile);
   const newCache = {};
+  const source = resolveSourceDefault(opts);
+  // Error detail from the shared runtime replaces generated error code, so it
+  // is only on offer where that code is what the build would emit: not with
+  // schema-source frames (development builds), stub errors or the one-pass
+  // function, which are each asked for by name.
+  const sharable = errorsMode !== 'inline' && !source && !opts.abortEarly && opts.onePass !== true;
+  // `mode: 'schema'`, asked for by name: every module that can be is a schema
+  // module (its schema and a few lines), with the verdict and the errors from
+  // one runtime. Smaller and quicker to load than generated code, slower per
+  // check once warm.
+  if (opts.mode !== undefined && opts.mode !== 'code' && opts.mode !== 'schema') throw new Error(`build: mode must be code or schema (got "${opts.mode}")`);
+  const schemaMode = opts.mode === 'schema' && !opts.abortEarly;
 
   const compiled = [];
   const cached = [];
   const skipped = [];
   const failed = [];
   const warnings = [];
+  const entries = [];
+
+  const compileOne = (input, raw) => {
+    const schema = parseSchemaFile(input);
+    // The build is where an authoring mistake is cheapest to stop: a typo
+    // like maxLenght compiles into a validator that simply lacks the rule,
+    // and a compiled module fails even more quietly than a runtime one,
+    // since nobody ever revisits it. Findings fail the input's build.
+    if (opts.strictSchema) {
+      const { checkSchemaStrict } = require('./strict-check');
+      const problems = checkSchemaStrict(schema, {});
+      if (problems.length > 0) {
+        return { error: problems.map((x) => `strict mode: ${x.message} at ${x.path}`).join('; ') };
+      }
+    }
+    const v = new Validator(schema);
+    let sourceMap = null;
+    if (source) {
+      // Only attempt position map for JSON (the scanner is JSON-only).
+      const ext = path.extname(input).toLowerCase();
+      if (ext === '.json') {
+        try { sourceMap = buildPositionMap(raw.toString('utf8')); }
+        catch { sourceMap = null; }
+      }
+    }
+    const schemaFile = path.relative(process.cwd(), input) || input;
+    const inputWarnings = [];
+    const src = aot.toStandaloneModule(v, {
+      format,
+      abortEarly: !!opts.abortEarly,
+      onePass: opts.onePass === true ? true : undefined,
+      source,
+      sourceMap,
+      schemaFile,
+      formatMode: opts.formatMode,
+      onWarning: (w, meta) => inputWarnings.push({ message: w, kind: (meta && meta.kind) || 'general' }),
+    });
+    const compact = schemaMode && src
+      ? aot.toSchemaModule(v, { format, runtime: RUNTIME_PLACEHOLDER })
+      : sharable && src ? aot.toCompactModule(v, { format, formatMode: opts.formatMode, errorRuntime: RUNTIME_PLACEHOLDER }) : null;
+    // The runtime parts this module's schema needs (see runtimeFeatures).
+    const features = compact ? require('./error-runtime').runtimeFeatures([require('./schema-strip').stripAnnotations(v._schemaObj)]) : null;
+    // A module that imports the pattern engine needs it in the runtime,
+    // whatever the schema scan said.
+    if (features && compact.includes('_ataCompileSafe')) features['safe-regex'] = true;
+    return { schema, src, compact, features, inputWarnings };
+  };
 
   for (const input of inputs) {
     try {
@@ -107,100 +190,119 @@ async function build(opts) {
       const inputHash = hashContent(raw);
       const output = outputPathFor(input, { ...opts, format });
       const cacheEntry = cache[input];
-      if (opts.check) {
-        const upToDate = (
-          cacheEntry &&
-          cacheEntry.inputHash === inputHash &&
-          cacheEntry.output === output &&
-          fs.existsSync(output) &&
-          cacheEntry.outputHash === hashContent(fs.readFileSync(output))
-        );
-        if (upToDate) {
-          cached.push({ input, output });
-        }
-        continue;
-      }
-      if (
+      const fresh = !!(
         cacheEntry &&
         cacheEntry.inputHash === inputHash &&
         cacheEntry.output === output &&
+        !!cacheEntry.sharable === sharable &&
+        !!cacheEntry.schemaMode === schemaMode &&
         fs.existsSync(output) &&
         cacheEntry.outputHash === hashContent(fs.readFileSync(output))
-      ) {
-        cached.push({ input, output });
-        newCache[input] = cacheEntry;
+      );
+      if (opts.check) {
+        if (fresh) cached.push({ input, output });
         continue;
       }
-      const schema = parseSchemaFile(input);
-      // The build is where an authoring mistake is cheapest to stop: a typo
-      // like maxLenght compiles into a validator that simply lacks the rule,
-      // and a compiled module fails even more quietly than a runtime one,
-      // since nobody ever revisits it. Findings fail the input's build.
-      if (opts.strictSchema) {
-        const { checkSchemaStrict } = require('./strict-check');
-        const problems = checkSchemaStrict(schema, {});
-        if (problems.length > 0) {
-          failed.push({ input, error: problems.map((x) => `strict mode: ${x.message} at ${x.path}`).join('; ') });
-          continue;
-        }
-      }
-      const v = new Validator(schema);
-      const source = resolveSourceDefault(opts);
-      let sourceMap = null;
-      if (source) {
-        // Only attempt position map for JSON (the scanner is JSON-only).
-        const ext = path.extname(input).toLowerCase();
-        if (ext === '.json') {
-          try { sourceMap = buildPositionMap(raw.toString('utf8')); }
-          catch { sourceMap = null; }
-        }
+      if (fresh) {
+        entries.push({ input, output, raw, inputHash, cacheEntry, fullGz: cacheEntry.fullGz, compactGz: cacheEntry.compactGz, features: cacheEntry.features || null });
+        continue;
       }
-      const schemaFile = path.relative(process.cwd(), input) || input;
-      const inputWarnings = [];
-      const src = aot.toStandaloneModule(v, {
-        format,
-        abortEarly: !!opts.abortEarly,
-        onePass: opts.onePass === true ? true : undefined,
-        source,
-        sourceMap,
-        schemaFile,
-        formatMode: opts.formatMode,
-        onWarning: (w, meta) => inputWarnings.push({ message: w, kind: (meta && meta.kind) || 'general' }),
-      });
-      if (inputWarnings.length > 0) {
+      const r = compileOne(input, raw);
+      if (r.error) { failed.push({ input, error: r.error }); continue; }
+      if (r.inputWarnings.length > 0) {
         if (opts.strict) {
-          failed.push({ input, error: inputWarnings.map((x) => x.message).join('; ') });
+          failed.push({ input, error: r.inputWarnings.map((x) => x.message).join('; ') });
           continue;
         }
         // `kind` says which capability degraded ('error-detail', 'parse'),
         // so a caller that requested both can tell the warnings apart.
-        for (const x of inputWarnings) warnings.push({ input, warning: x.message, kind: x.kind });
+        for (const x of r.inputWarnings) warnings.push({ input, warning: x.message, kind: x.kind });
       }
-      if (!src) {
+      if (!r.src) {
         const reason = 'schema is not AOT-compatible (toStandaloneModule returned null)';
         if (opts.strict) failed.push({ input, error: reason });
         else skipped.push({ input, reason });
         continue;
       }
+      entries.push({
+        input, output, raw, inputHash, schema: r.schema, src: r.src, compact: r.compact, features: r.features,
+        fullGz: zlib.gzipSync(r.src).length,
+        compactGz: r.compact ? zlib.gzipSync(r.compact).length : null,
+      });
+    } catch (e) {
+      failed.push({ input, error: e.message });
+    }
+  }
+
+  if (opts.check) {
+    const staleCount = inputs.length - cached.length;
+    return { compiled: [], cached, skipped, failed, warnings, staleCount };
+  }
+
+  // A module takes its errors from the shared runtime when that makes it
+  // smaller, and the runtime is written when the modules that use it save
+  // more than it weighs. With `errors: 'shared'` every module that can, does.
+  // The runtime carries only the parts the compact modules' schemas need
+  // (formats, the pattern engine, deep equality); an entry with no record of
+  // its needs (a cache written before this) counts as needing everything.
+  const { errorRuntimeSource, runtimeFeatures } = require('./error-runtime');
+  const ATA_VERSION = require('./version');
+  const unionOf = (list) => {
+    const out = runtimeFeatures([]);
+    for (const e of list) for (const k of Object.keys(out)) if (!e.features || e.features[k]) out[k] = true;
+    return out;
+  };
+  const candidates = entries.filter((e) => typeof e.compactGz === 'number' && (schemaMode || errorsMode === 'shared' || e.compactGz < e.fullGz));
+  let runtime = null;
+  if ((sharable || schemaMode) && candidates.length > 0) {
+    const runtimeSrc = errorRuntimeSource(format, ATA_VERSION, unionOf(candidates), schemaMode);
+    const runtimeGz = zlib.gzipSync(runtimeSrc).length;
+    let saving = 0;
+    for (const e of candidates) saving += e.fullGz - e.compactGz;
+    const use = schemaMode || errorsMode === 'shared' || saving > runtimeGz;
+    if (use) runtime = { path: runtimePathFor(entries.map((e) => e.output), opts, format), src: runtimeSrc, gz: runtimeGz };
+  }
+  for (const e of entries) {
+    e.mode = runtime !== null && candidates.includes(e) ? (schemaMode ? 'schema' : 'compact') : 'inline';
+  }
+
+  for (const e of entries) {
+    const { input, output } = e;
+    try {
+      if (e.cacheEntry) {
+        const sameRuntime = e.mode === 'inline' || (runtime !== null && e.cacheEntry.runtime === runtime.path);
+        if (e.cacheEntry.mode === e.mode && sameRuntime) {
+          cached.push({ input, output });
+          newCache[input] = e.cacheEntry;
+          continue;
+        }
+        // The build's choice for this module changed: compile it again.
+        const r = compileOne(input, e.raw);
+        if (r.error || !r.src) { failed.push({ input, error: r.error || 'schema is not AOT-compatible' }); continue; }
+        e.schema = r.schema; e.src = r.src; e.compact = r.compact; e.features = r.features;
+        if (e.mode !== 'inline' && !r.compact) e.mode = 'inline';
+      }
+      const src = e.mode !== 'inline'
+        ? e.compact.split(JSON.stringify(RUNTIME_PLACEHOLDER)).join(JSON.stringify(importSpecifier(output, runtime.path)))
+        : e.src;
       fs.mkdirSync(path.dirname(output), { recursive: true });
       fs.writeFileSync(output, src);
       const outBytes = Buffer.byteLength(src, 'utf8');
-      const gz = zlib.gzipSync(src);
-      const gzBytes = gz.length;
+      const gzBytes = zlib.gzipSync(src).length;
       if (typeof opts.maxSize === 'number' && gzBytes > opts.maxSize) {
         // Roll back the write so a failed build doesn't leave a stale artifact.
         try { fs.unlinkSync(output); } catch {}
         failed.push({ input, error: `output ${output} exceeds --max-size: ${gzBytes} > ${opts.maxSize} (gzipped bytes)` });
         continue;
       }
-      compiled.push({ input, output, bytes: outBytes, gzipBytes: gzBytes });
+      compiled.push({ input, output, bytes: outBytes, gzipBytes: gzBytes, errors: e.mode });
       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(schema, { name: typeName });
+        const dts = toTypeScript(e.schema, { name: typeName });
         const ext = path.extname(output);
         const dtsExt = ext === '.mjs' ? '.d.mts'
           : ext === '.cjs' ? '.d.cts'
@@ -209,23 +311,35 @@ async function build(opts) {
         fs.writeFileSync(base + dtsExt, dts);
       }
       newCache[input] = {
-        inputHash,
+        inputHash: e.inputHash,
         output,
         outputHash: hashContent(Buffer.from(src, 'utf8')),
+        sharable,
+        schemaMode,
+        mode: e.mode,
+        runtime: e.mode !== 'inline' ? runtime.path : undefined,
+        fullGz: e.fullGz,
+        compactGz: e.compactGz,
+        features: e.features || undefined,
       };
-    } catch (e) {
-      failed.push({ input, error: e.message });
+    } catch (err) {
+      failed.push({ input, error: err.message });
     }
   }
 
-  if (opts.check) {
-    const staleCount = inputs.length - cached.length;
-    return { compiled: [], cached, skipped, failed, warnings, staleCount };
+  let runtimeReport = null;
+  if (runtime !== null && entries.some((e) => e.mode !== 'inline')) {
+    const current = fs.existsSync(runtime.path) ? fs.readFileSync(runtime.path, 'utf8') : null;
+    if (current !== runtime.src) {
+      fs.mkdirSync(path.dirname(runtime.path), { recursive: true });
+      fs.writeFileSync(runtime.path, runtime.src);
+    }
+    runtimeReport = { output: runtime.path, bytes: Buffer.byteLength(runtime.src, 'utf8'), gzipBytes: runtime.gz };
   }
 
   writeCache(opts.cacheFile, newCache);
 
-  return { compiled, cached, skipped, failed, warnings };
+  return { compiled, cached, skipped, failed, warnings, runtime: runtimeReport };
 }
 
 async function watch(opts, onReport) {
@@ -322,12 +436,41 @@ function compiledSchemaFor(schema) {
 // error function the generator declines (unevaluated* among them), where the
 // module would report every failure as the ATA9000 stub while the runtime
 // reports the real errors.
+//
+// With `errorRuntime` (an import specifier, usually 'ata-validator/error-runtime'),
+// the module is written compact where the validator allows it: the verdict and
+// the schema, with errors from that runtime (see toCompactModule). A plugin
+// writes it in place of the self-contained module when that is smaller for
+// the whole bundle; the runtime is shared by every compact module in it.
+// A plugin asks for both modules of one schema (the self-contained one, and
+// the compact one to compare): one Validator answers both, so the verdict
+// function compiles once. Keyed by the schema object the plugin passes.
+const _validators = new WeakMap();
+function validatorFor(schema) {
+  let v = _validators.get(schema);
+  // Built with an options object, empty, so it stays out of the identity
+  // cache: `new Validator(schema)` in the caller's own code must get its own
+  // instance, not this compiled one.
+  if (v === undefined) { v = new Validator(schema, {}); _validators.set(schema, v); }
+  return v;
+}
+
 function compiledModuleFor(schema, opts) {
   if (!compiledEligible(schema)) return null;
+  if (opts && typeof opts.errorRuntime === 'string') {
+    try {
+      const v = validatorFor(schema);
+      const src = aot.toCompactModule(v, { format: opts.format || 'esm', errorRuntime: opts.errorRuntime });
+      if (src) return src;
+    } catch {
+      return null;
+    }
+    // Not writable as a compact module: the self-contained one below.
+  }
   let degraded = false;
   let src;
   try {
-    src = toStandaloneModule(schema, {
+    src = aot.toStandaloneModule(validatorFor(schema), {
       format: (opts && opts.format) || 'esm',
       onWarning: (msg, info) => { if (info && info.kind === 'error-detail') degraded = true; },
     });