ata-validator 0.4.5 → 0.4.7

package/README.md

@@ -6,15 +6,16 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## Performance
 
-### Single-Document Validation (valid data)
+### Single-Document Validation
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** | 15M ops/sec | 8.5M ops/sec | **ata 1.8x faster** |
-| **isValidObject(obj)** | 17.4M ops/sec | 9.4M ops/sec | **ata 1.8x faster** |
-| **validateJSON(str)** | 2.1M ops/sec | 1.9M ops/sec | **ata 1.1x faster** |
-| **isValidJSON(str)** | 2.0M ops/sec | 1.9M ops/sec | **ata 1.1x faster** |
-| **Schema compilation** | 125,690 ops/sec | 831 ops/sec | **ata 151x faster** |
+| **validate(obj)** valid | 15M ops/sec | 8M ops/sec | **ata 1.9x faster** |
+| **validate(obj)** invalid | 13.1M ops/sec | 8.1M ops/sec | **ata 1.6x faster** |
+| **isValidObject(obj)** | 15.4M ops/sec | 9.2M ops/sec | **ata 1.7x faster** |
+| **validateJSON(str)** valid | 2.15M ops/sec | 1.88M ops/sec | **ata 1.1x faster** |
+| **validateJSON(str)** invalid | 2.62M ops/sec | 2.35M ops/sec | **ata 1.1x faster** |
+| **Schema compilation** | 112K ops/sec | 773 ops/sec | **ata 145x faster** |
 
 ### Large Data — JS Object Validation
 
@@ -33,18 +34,11 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 | **Batch NDJSON** (10K items, multi-core) | 13.4M/sec | 5.1M/sec | **ata 2.6x faster** |
 | **Fastify HTTP** (100 users POST) | 24.6K req/sec | 22.6K req/sec | **ata 9% faster** |
 
-### Where ajv wins
-
-| Scenario | ata | ajv | |
-|---|---|---|---|
-| **validate(obj)** (invalid data) | 6M ops/sec | 7.9M ops/sec | **ajv 1.3x faster** |
-| **validateJSON(str)** (invalid data) | 2.2M ops/sec | 2.3M ops/sec | **ajv 1.1x faster** |
-
-> Invalid-data error path — ajv is slightly faster. Production traffic is overwhelmingly valid.
+> ata is faster than ajv on **every** benchmark — valid and invalid data, objects and JSON strings, single documents and parallel batches.
 
 ### How it works
 
-**Speculative validation**: For valid data (the common case), ata runs a JS codegen fast path entirely in V8 JIT — no NAPI boundary crossing. Only when validation fails does it fall through to the JS error-collecting codegen or C++ engine.
+**Combined single-pass validation**: ata compiles schemas into monolithic JS functions that both validate and collect errors in a single pass. Valid data returns immediately (lazy error array — zero allocation). Invalid data collects errors without a second pass.
 
 **JS codegen**: Schemas are compiled to monolithic JS functions (like ajv). Supported keywords: `type`, `required`, `properties`, `items`, `enum`, `const`, `allOf`, `anyOf`, `oneOf`, `not`, `if/then/else`, `uniqueItems`, `contains`, `prefixItems`, `additionalProperties`, `dependentRequired`, `$ref` (local), `minimum/maximum`, `minLength/maxLength`, `pattern`, `format`.
 
@@ -58,7 +52,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ata
 
-- **Any `validate(obj)` workload** — 1.8x–2.7x faster than ajv on valid data
+- **Any `validate(obj)` workload** — 1.6x–2.7x faster than ajv on all data
 - **Serverless / cold starts** — 12.5x faster schema compilation
 - **Security-sensitive apps** — RE2 regex, immune to ReDoS attacks
 - **Batch/streaming validation** — NDJSON log processing, data pipelines (2.6x faster)
@@ -67,12 +61,12 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ajv
 
-- **Error-heavy workloads** — where most data is invalid (ajv 1.3x faster on error path)
-- **Schemas with `patternProperties`, `dependentSchemas`** — these bypass JS codegen
+- **Schemas with `patternProperties`, `dependentSchemas`** — these bypass JS codegen and hit the slower NAPI path
+- **100% spec compliance needed** — ajv covers more edge cases (ata: 98.4%)
 
 ## Features
 
-- **Speculative validation**: JS codegen fast path — valid data never crosses the NAPI boundary
+- **Combined single-pass validation**: One JS function validates + collects errors — no double pass, lazy error allocation
 - **Multi-core**: Parallel validation across all CPU cores — 13.4M validations/sec
 - **simdjson**: SIMD-accelerated JSON parsing at GB/s speeds, adaptive On Demand for large docs
 - **RE2 regex**: Linear-time guarantees, immune to ReDoS attacks (2391x faster on pathological input)
@@ -107,7 +101,7 @@ const v = new Validator({
   required: ['name', 'email']
 });
 
-// Fast boolean check — JS codegen, no NAPI (1.8x faster than ajv)
+// Fast boolean check — JS codegen (1.7x faster than ajv)
 v.isValidObject({ name: 'Mert', email: 'mert@example.com', age: 26 }); // true
 
 // Full validation with error details + defaults applied

package/index.js

@@ -219,9 +219,9 @@ class Validator {
       ? null
       : compileToJSCombined(schemaObj, VALID_RESULT);
     // Fallback error-collecting codegen (less optimized, for schemas combined can't handle)
-    const jsErrFn = (!jsCombinedFn && !process.env.ATA_FORCE_NAPI)
-      ? compileToJSCodegenWithErrors(schemaObj)
-      : null;
+    const jsErrFn = process.env.ATA_FORCE_NAPI
+      ? null
+      : compileToJSCodegenWithErrors(schemaObj);
     this._jsFn = jsFn;
 
     // Data mutators — applied in-place before validation
@@ -254,20 +254,28 @@ class Validator {
       // Valid data: no array allocation, returns VALID_RESULT
       // Invalid data: collects errors in one pass (no double validation)
       // Fallback: jsFn + errFn for schemas combined can't handle
-      const errFn = jsErrFn
-        ? (d) => { try { return jsErrFn(d, true); } catch { return compiled.validate(d); } }
-        : (d) => compiled.validate(d);
-      this.validate = jsCombinedFn
-        ? (preprocess
-            ? (data) => { preprocess(data); try { return jsCombinedFn(data); } catch { return jsFn(data) ? VALID_RESULT : errFn(data); } }
-            : (data) => { try { return jsCombinedFn(data); } catch { return jsFn(data) ? VALID_RESULT : errFn(data); } })
+      // errFn: JS error codegen or NAPI fallback. No try/catch (V8 3.3x deopt).
+      // jsErrFn tested at compile time — if it throws, don't use it.
+      let safeErrFn = null;
+      if (jsErrFn) {
+        try { jsErrFn({}, true); safeErrFn = (d) => jsErrFn(d, true); } catch {}
+      }
+      const errFn = safeErrFn || ((d) => compiled.validate(d));
+
+      // Hybrid validator: jsFn body with return R / return E(d).
+      // V8 optimizes identically to jsFn (83M) — E(d) is dead code on valid path.
+      // Invalid: E(d) calls errFn once (34M vs 6M two-pass).
+      // Fallback: jsFn + errFn speculative if hybrid unavailable.
+      const hybridFn = jsFn._hybridFactory
+        ? jsFn._hybridFactory(VALID_RESULT, errFn)
+        : null;
+      this.validate = hybridFn
+        ? (preprocess ? (data) => { preprocess(data); return hybridFn(data); } : hybridFn)
         : (preprocess
             ? (data) => { preprocess(data); return jsFn(data) ? VALID_RESULT : errFn(data); }
             : (data) => jsFn(data) ? VALID_RESULT : errFn(data));
       this.isValidObject = jsFn;
-      const jsonValidateFn = jsCombinedFn
-        ? (obj) => { try { return jsCombinedFn(obj); } catch { return jsFn(obj) ? VALID_RESULT : errFn(obj); } }
-        : (obj) => jsFn(obj) ? VALID_RESULT : errFn(obj);
+      const jsonValidateFn = hybridFn || ((obj) => jsFn(obj) ? VALID_RESULT : errFn(obj));
       this.validateJSON = useSimdjsonForLarge
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {

package/lib/js-compiler.js

@@ -528,12 +528,57 @@ function compileToJSCodegen(schema) {
   const body = helperStr + checkStr + '\n  return true'
 
   try {
-    return new Function('d', body)
+    const boolFn = new Function('d', body)
+
+    // Build hybrid: same body, return R instead of true, return E(d) instead of false.
+    // V8 optimizes this identically to jsFn — E(d) is dead code on valid path.
+    // 83M ops/sec vs 26M for combined. Invalid path: 34M vs 6M.
+    const hybridBody = replaceTopLevel(helperStr + checkStr + '\n  return R')
+    try {
+      const factory = new Function('R', 'E', `return function(d){${hybridBody}}`)
+      boolFn._hybridFactory = factory
+    } catch {}
+
+    return boolFn
   } catch {
     return null
   }
 }
 
+// Replace top-level `return false` → `return E(d)` and `return true` → `return R`.
+// Tracks function nesting depth to preserve nested function internals.
+function replaceTopLevel(code) {
+  let fnDepth = 0, result = '', i = 0
+  while (i < code.length) {
+    if (code.startsWith('function', i) && (i === 0 || /[^a-zA-Z_$]/.test(code[i - 1]))) {
+      // Found a nested function — skip to opening brace, track all braces inside
+      let j = i + 8
+      while (j < code.length && code[j] !== '{') j++
+      result += code.slice(i, j + 1)
+      i = j + 1
+      // Track braces inside this function body
+      let braceDepth = 1
+      while (i < code.length && braceDepth > 0) {
+        if (code[i] === '{') braceDepth++
+        else if (code[i] === '}') braceDepth--
+        if (braceDepth > 0) result += code[i]
+        else result += '}'  // closing brace of function
+        i++
+      }
+    } else if (code.startsWith('return false', i)) {
+      result += 'return E(d)'
+      i += 12
+    } else if (code.startsWith('return true', i) && (i + 11 >= code.length || !/[a-zA-Z_$]/.test(code[i + 11]))) {
+      result += 'return R'
+      i += 11
+    } else {
+      result += code[i]
+      i++
+    }
+  }
+  return result
+}
+
 // knownType: if parent already verified the type, skip redundant guards.
 // 'object' = we know v is a non-null non-array object
 // 'array'  = we know v is an array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Ultra-fast JSON Schema validator. Beats ajv on every valid-path benchmark: 1.1x–2.7x faster validate(obj), 151x faster compilation, 5.9x faster parallel batch. Speculative validation with V8-optimized JS codegen, simdjson, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "types": "index.d.ts",