ata-validator 1.61.3 → 1.62.0

package/lib/verify.js

@@ -20,7 +20,8 @@ const { pathToFileURL } = require('url')
 function rng (seed) {
   let x = (seed >>> 0) || 0x9e3779b9
   const next = () => { x ^= x << 13; x ^= x >>> 17; x ^= x << 5; return (x >>> 0) / 4294967296 }
-  return { next, int: (n) => Math.floor(next() * n), pick: (a) => a[Math.floor(next() * a.length)], chance: (p) => next() < p }
+  // `nodes` counts the values of the document being made (makeValid).
+  return { next, int: (n) => Math.floor(next() * n), pick: (a) => a[Math.floor(next() * a.length)], chance: (p) => next() < p, nodes: 0 }
 }
 
 const WORDS = ['ada', 'Zoë', 'order', 'x', 'north-west', 'a b', 'ÄÖÜ', 'sku-1001', 'TENOFF', 'hello world', '', '0', 'null', '😀', 'line\nbreak', '  ']
@@ -48,9 +49,18 @@ const FORMAT_EXAMPLES = {
   'json-pointer': ['/a/b', 'a/b', '/a~1b', '/a~2'],
 }
 
+const { patternIsSafe, compileSafe } = require('./safe-regex')
+
+// How many values one generated document may hold. Nested minItems multiply
+// (20 at six levels is 64 million integers) and ran the process out of
+// memory; past the budget the document is refused with a message instead.
+const NODE_BUDGET = 100000
+
 // A value meant to satisfy `schema`, built from its keywords; where the
 // schema says little, something plausible of the kind.
 function makeValid (schema, r, defs, depth) {
+  if (depth === 0) r.nodes = 0
+  if (++r.nodes > NODE_BUDGET) throw new Error(`a document for this schema holds more than ${NODE_BUDGET} values (nested minItems or required properties); ata verify does not generate it`)
   if (schema === true || schema === undefined) return r.pick([1, 'x', true, null, {}, []])
   if (schema === false) return undefined
   if (typeof schema !== 'object' || schema === null) return null
@@ -103,16 +113,22 @@ function makeValid (schema, r, defs, depth) {
         // Any other pattern: a candidate that matches, when one does, so the
         // generated documents reach past the pattern; else a word, which the
         // schema then refuses, and that is a document too.
-        let re = null
-        try { re = new RegExp(schema.pattern, 'u') } catch {}
+        // On the linear engine: the candidates are fixed strings, and a
+        // pattern that backtracks on them (^(((a+)+)+)+b$ on sixteen a's)
+        // held the platform RegExp for seconds. A pattern the engine does not
+        // take gets no candidate.
+        const re = patternIsSafe(schema.pattern) ? compileSafe(schema.pattern) : null
         if (re) {
           const matching = PATTERN_CANDIDATES.filter((c) => re.test(c) && [...c].length >= min && [...c].length <= max)
           if (matching.length) return r.pick(matching)
         }
       }
       let s = r.pick(WORDS)
-      while ([...s].length < min) s += 'a'
-      if ([...s].length > max) s = [...s].slice(0, max).join('')
+      // Counted once: padding one character at a time with the string spread
+      // for each count took 32 s for a minLength of 100000.
+      const len = [...s].length
+      if (len < min) s += 'a'.repeat(min - len)
+      else if (len > max) s = [...s].slice(0, max).join('')
       return s
     }
     case 'array': {
@@ -321,7 +337,10 @@ async function verifyOne ({ schemaFile, moduleFile, schema, generate: count = 20
   if (mod.schemaHash !== undefined && mod.schemaHash !== hash) report.stale = true
   let runtime
   try { runtime = new Validator(schema, {}) } catch (e) { report.error = `schema does not compile: ${e.message}`; return report }
-  const docs = generate(schema, count, seed, (d) => { try { return runtime.isValidObject(clone(d)) } catch { return false } }).map((d, i) => ({ source: `generated #${i + 1}`, doc: d }))
+  let docs
+  try {
+    docs = generate(schema, count, seed, (d) => { try { return runtime.isValidObject(clone(d)) } catch { return false } }).map((d, i) => ({ source: `generated #${i + 1}`, doc: d }))
+  } catch (e) { report.error = `documents cannot be generated: ${e.message}`; return report }
   report.generated = docs.length
   const sampleDocs = readSamples(samples)
   report.samples = sampleDocs.length

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.61.3';
+module.exports = '1.62.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.61.3",
+  "version": "1.62.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -89,6 +89,11 @@
       "import": "./compiled-standard.mjs",
       "default": "./lib/compiled-standard.js"
     },
+    "./stream": {
+      "types": "./stream.d.ts",
+      "import": "./stream.mjs",
+      "default": "./stream.js"
+    },
     "./lite": {
       "types": "./lite.d.ts",
       "import": "./lite.mjs",
@@ -118,6 +123,7 @@
   },
   "browser": {
     "./lib/native-load.js": "./lib/native-load.browser.js",
+    "./lib/native-attach.js": "./lib/native-attach.browser.js",
     "./lib/aot.js": "./lib/aot.browser.js",
     "./lib/buffer-gate.js": "./lib/buffer-gate.browser.js",
     "./lib/interpreter.js": "./lib/interpreter.browser.js",
@@ -224,6 +230,9 @@
     "compiled-bare-rich.d.ts",
     "compiled-standard.mjs",
     "compiled-standard.d.ts",
+    "stream.js",
+    "stream.mjs",
+    "stream.d.ts",
     "lite.js",
     "lite.mjs",
     "lite.d.ts",
@@ -238,13 +247,13 @@
     "codegen.d.ts"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.61.3",
-    "@ata-validator/native-darwin-x64": "1.61.3",
-    "@ata-validator/native-linux-arm64-gnu": "1.61.3",
-    "@ata-validator/native-linux-arm64-musl": "1.61.3",
-    "@ata-validator/native-linux-x64-gnu": "1.61.3",
-    "@ata-validator/native-linux-x64-musl": "1.61.3",
-    "@ata-validator/native-win32-x64": "1.61.3"
+    "@ata-validator/native-darwin-arm64": "1.62.0",
+    "@ata-validator/native-darwin-x64": "1.62.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.62.0",
+    "@ata-validator/native-linux-arm64-musl": "1.62.0",
+    "@ata-validator/native-linux-x64-gnu": "1.62.0",
+    "@ata-validator/native-linux-x64-musl": "1.62.0",
+    "@ata-validator/native-win32-x64": "1.62.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"

package/stream.d.ts

@@ -0,0 +1,51 @@
+import { Validator, ValidationError } from './index';
+
+/** Options of a record stream. */
+export interface StreamOptions {
+  /** How the body carries its records: one JSON document per line, a JSON array, or decided from the first non-blank character (default). */
+  format?: 'ndjson' | 'array' | 'auto';
+  /** Stop at the first record that fails (default true); false sees every record and lists every failure. */
+  stopOnFirst?: boolean;
+  /** Called with each record that passed, parsed, and its index from zero. */
+  onRecord?: (record: unknown, index: number) => void;
+}
+
+/** One record's failure: its index from zero and the errors validate() gives for it, or a parse error with keyword `__parse__`. */
+export interface RecordFailure {
+  valid: false;
+  record: number;
+  errors: ValidationError[];
+}
+
+/** What end() returns: whether every record passed, how many were read, and the failures seen. */
+export interface StreamResult {
+  valid: boolean;
+  records: number;
+  errors: RecordFailure[];
+}
+
+/** A record stream: feed chunks as they arrive, get the first failure the moment its record is complete. */
+export class RecordStream {
+  constructor(validator: Validator<unknown>, opts?: StreamOptions);
+  /** Records read so far. */
+  readonly records: number;
+  /** Failures so far. */
+  readonly failures: RecordFailure[];
+  /** True once the stream stopped, at a failure or at end(). */
+  readonly done: boolean;
+  /** Feed a chunk. Returns null while every record so far passes, or the first failure. */
+  push(chunk: string | Uint8Array): RecordFailure | null;
+  /** Close the input. An unfinished record or an unclosed array is a parse failure. */
+  end(): StreamResult;
+}
+
+export function streamValidator(validator: Validator<unknown>, opts?: StreamOptions): RecordStream;
+
+/**
+ * Read an async source (a Node Readable, a Web ReadableStream, any iterable of
+ * chunks) through a record stream. At the first failure the source is stopped:
+ * a Node stream is destroyed, a Web stream's reader cancelled.
+ */
+export function validateStream(validator: Validator<unknown>, source: AsyncIterable<string | Uint8Array> | Iterable<string | Uint8Array> | ReadableStream<Uint8Array | string>, opts?: StreamOptions): Promise<StreamResult>;
+
+export const PARSE_KEYWORD: '__parse__';

package/stream.js

@@ -0,0 +1,3 @@
+'use strict';
+// ata-validator/stream: validation as the body arrives, record by record.
+module.exports = require('./lib/stream.js');

package/stream.mjs

@@ -0,0 +1,3 @@
+import mod from './lib/stream.js';
+export const { RecordStream, streamValidator, validateStream, PARSE_KEYWORD } = mod;
+export default mod;