ata-validator 0.4.12 → 0.4.14

package/README.md

@@ -10,12 +10,11 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 68M ops/sec | 8M ops/sec | **ata 8.5x faster** |
-| **validate(obj)** invalid | 17M ops/sec | 8M ops/sec | **ata 2.1x faster** |
-| **isValidObject(obj)** | 15.4M ops/sec | 9.2M ops/sec | **ata 1.7x faster** |
-| **validateJSON(str)** valid | 3.0M ops/sec | 1.9M ops/sec | **ata 1.6x faster** |
-| **validateJSON(str)** invalid | 2.7M ops/sec | 2.3M ops/sec | **ata 1.2x faster** |
-| **Schema compilation** | 113K ops/sec | 818 ops/sec | **ata 138x faster** |
+| **validate(obj)** valid | 25.5M ops/sec | 19.3M ops/sec | **ata 1.3x faster** |
+| **validate(obj)** invalid | 17.7M ops/sec | 13.5M ops/sec | **ata 1.3x faster** |
+| **isValidObject(obj)** | 39.5M ops/sec | 17.6M ops/sec | **ata 2.2x faster** |
+| **Constructor cold start** | 1.28M ops/sec | 812 ops/sec | **ata 1,580x faster** |
+| **First validation** | 396K ops/sec | 880 ops/sec | **ata 450x faster** |
 
 > validate(obj) numbers are isolated single-schema benchmarks. Multi-schema benchmark overhead reduces throughput; real-world numbers depend on workload.
 
@@ -31,17 +30,16 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **Serverless cold start** (50 schemas) | 7.7ms | 96ms | **ata 12.5x faster** |
+| **Serverless cold start** (50 schemas) | 0.1ms | 23ms | **ata 242x faster** |
 | **ReDoS protection** (`^(a+)+$`) | 0.3ms | 765ms | **ata immune (RE2)** |
 | **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** |
-| **Fastify startup** (500 routes) | 46ms | 77ms (standalone) | **ata 1.7x faster** |
+| **Fastify startup** (5 routes) | 0.5ms | 6.0ms | **ata 12x faster** |
 
 > Isolated single-schema benchmarks. Results vary by workload and hardware.
 
 ### How it works
 
-**Hybrid validator**: ata compiles schemas into monolithic JS functions identical to the boolean fast path, but returning `VALID_RESULT` on success and calling the error collector on failure. V8 TurboFan optimizes it identically to a pure boolean function - error code is dead code on the valid path. No try/catch (3.3x V8 deopt), no lazy arrays, no double-pass.
+**Combined single-pass validator**: ata compiles schemas into a single function that validates and collects errors in one pass. Valid data returns `VALID_RESULT` with zero allocation. Invalid data collects errors inline - no double validation, no try/catch (3.3x V8 deopt). Lazy compilation defers all work to first usage - constructor is near-zero cost.
 
 **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`.
 
@@ -55,8 +53,8 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ata
 
-- **High-throughput `validate(obj)`** - 68M ops/sec valid, 17M ops/sec invalid
-- **Serverless / cold starts** - 12.5x faster schema compilation
+- **High-throughput `validate(obj)`** - 25.5M ops/sec valid, 17.7M ops/sec invalid
+- **Serverless / cold starts** - 1,580x faster constructor, 450x faster first validation
 - **Security-sensitive apps** - RE2 regex, immune to ReDoS attacks
 - **Batch/streaming validation** - NDJSON log processing, data pipelines (2.6x faster)
 - **Standard Schema V1** - native support for Fastify v5, tRPC, TanStack
@@ -69,7 +67,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## Features
 
-- **Hybrid validator**: 68M ops/sec - same function body as boolean check, returns result or calls error collector. No try/catch, no double pass
+- **Hybrid validator**: 25.5M ops/sec valid, 17.7M ops/sec invalid - codegen + single-pass error collection. No try/catch, no double pass. Schema compilation cache for repeated schemas
 - **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)
@@ -104,7 +102,7 @@ const v = new Validator({
   required: ['name', 'email']
 });
 
-// Fast boolean check - JS codegen, 68M ops/sec
+// Fast boolean check - JS codegen, 15.3M ops/sec
 v.isValidObject({ name: 'Mert', email: 'mert@example.com', age: 26 }); // true
 
 // Full validation with error details + defaults applied
@@ -152,7 +150,7 @@ fs.writeFileSync('./bundle.js', Validator.bundleCompact(schemas));
 const validators = Validator.loadBundle(require('./bundle.js'), schemas);
 ```
 
-**Fastify startup (500 routes): ajv standalone 77ms → ata standalone 46ms (1.7x faster)**
+**Fastify startup (5 routes): ajv 6.0ms → ata 0.5ms (12x faster, no build step needed)**
 
 ### Standard Schema V1
 

package/index.js

@@ -205,6 +205,9 @@ function collectRemovals(schema, actions, path) {
   }
 }
 
+// Schema compilation cache: same schema string -> reuse compiled functions
+const _compileCache = new Map();
+
 const SIMDJSON_PADDING = 64;
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -254,7 +257,7 @@ class Validator {
       return this.validate(data);
     };
     this.isValidObject = (data) => {
-      this._ensureCompiled();
+      this._ensureCodegen();
       return this.isValidObject(data);
     };
     this.validateJSON = (jsonStr) => {
@@ -299,17 +302,21 @@ class Validator {
     const schemaObj = this._schemaObj;
     const options = this._options;
 
-    // Pure JS fast path -- no NAPI, runs in V8 JIT
-    // Set ATA_FORCE_NAPI=1 to disable JS codegen (for correctness testing)
-    const jsFn = process.env.ATA_FORCE_NAPI
-      ? null
-      : compileToJSCodegen(schemaObj) || compileToJS(schemaObj);
-    const jsCombinedFn = process.env.ATA_FORCE_NAPI
-      ? null
-      : compileToJSCombined(schemaObj, VALID_RESULT);
-    const jsErrFn = process.env.ATA_FORCE_NAPI
-      ? null
-      : compileToJSCodegenWithErrors(schemaObj);
+    // Check cache first -- reuse compiled functions for same schema
+    const cached = _compileCache.get(this._schemaStr);
+    let jsFn, jsCombinedFn, jsErrFn;
+    if (cached && !process.env.ATA_FORCE_NAPI) {
+      jsFn = cached.jsFn;
+      jsCombinedFn = cached.combined;
+      jsErrFn = cached.errFn;
+    } else if (!process.env.ATA_FORCE_NAPI) {
+      jsFn = compileToJSCodegen(schemaObj) || compileToJS(schemaObj);
+      jsCombinedFn = compileToJSCombined(schemaObj, VALID_RESULT);
+      jsErrFn = compileToJSCodegenWithErrors(schemaObj);
+      _compileCache.set(this._schemaStr, { jsFn, combined: jsCombinedFn, errFn: jsErrFn });
+    } else {
+      jsFn = null; jsCombinedFn = null; jsErrFn = null;
+    }
     this._jsFn = jsFn;
 
     // Data mutators -- applied in-place before validation
@@ -491,6 +498,25 @@ class Validator {
     this._fastSlot = native.fastRegister(this._schemaStr);
   }
 
+  _ensureCodegen() {
+    if (this._jsFn) return;
+    if (process.env.ATA_FORCE_NAPI) return;
+    const cached = _compileCache.get(this._schemaStr);
+    if (cached && cached.jsFn) {
+      this._jsFn = cached.jsFn;
+      this.isValidObject = cached.jsFn;
+      return;
+    }
+    const jsFn = compileToJSCodegen(this._schemaObj) || compileToJS(this._schemaObj);
+    this._jsFn = jsFn;
+    if (jsFn) {
+      this.isValidObject = jsFn;
+      // seed cache with codegen, combined/errFn filled later by _ensureCompiled
+      if (!cached) _compileCache.set(this._schemaStr, { jsFn, combined: null, errFn: null });
+      else cached.jsFn = jsFn;
+    }
+  }
+
   // --- Standalone pre-compilation ---
   // Generate a JS module string that can be written to a file.
   // On next startup, load with Validator.fromStandalone() -- zero compile time.

package/lib/js-compiler.js

@@ -518,28 +518,53 @@ function compileToJSCodegen(schema) {
       schema.dependentSchemas ||
       schema.propertyNames) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], rootDefs, refStack: new Set() }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], closureVars: [], closureVals: [], rootDefs, refStack: new Set() }
   const lines = []
   genCode(schema, 'd', lines, ctx)
   if (lines.length === 0) return () => true
 
-  const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+  // Append deferred checks (additionalProperties) at the end
+  if (ctx.deferredChecks) {
+    for (const dc of ctx.deferredChecks) lines.push(dc)
+  }
+
   const checkStr = lines.join('\n  ')
-  const body = helperStr + checkStr + '\n  return true'
+
+  // Regex and helpers are passed as closure variables (not re-created per call)
+  const closureNames = ctx.closureVars
+  const closureValues = ctx.closureVals
+
+  // Pre-create regex objects once
+  for (const code of ctx.helperCode) {
+    const match = code.match(/^const (_re\d+)=new RegExp\((.+)\)$/)
+    if (match) {
+      closureNames.push(match[1])
+      closureValues.push(new RegExp(JSON.parse(match[2])))
+    }
+  }
+
+  const body = checkStr + '\n  return true'
 
   try {
-    const boolFn = new Function('d', body)
+    let boolFn
+    if (closureNames.length > 0) {
+      const factory = new Function(...closureNames, `return function(d){${body}}`)
+      boolFn = factory(...closureValues)
+    } else {
+      boolFn = new Function('d', body)
+    }
 
     // Build hybrid: same body, return R instead of true, return E(d) instead of false.
-    const hybridBody = replaceTopLevel(helperStr + checkStr + '\n  return R')
+    const hybridBody = replaceTopLevel(checkStr + '\n  return R')
     try {
-      const factory = new Function('R', 'E', `return function(d){${hybridBody}}`)
-      boolFn._hybridFactory = factory
+      const hybridFactory = new Function(...closureNames, 'R', 'E', `return function(d){${hybridBody}}`)
+      boolFn._hybridFactory = (R, E) => hybridFactory(...closureValues, R, E)
     } catch {}
 
-    // Store source for standalone compilation (pre-build to file)
-    boolFn._source = body
-    boolFn._hybridSource = hybridBody
+    // Store source for standalone compilation (includes regex inline for file output)
+    const helperStr = ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : ''
+    boolFn._source = helperStr + body
+    boolFn._hybridSource = helperStr + hybridBody
 
     return boolFn
   } catch {
@@ -614,7 +639,7 @@ function genCode(schema, v, lines, ctx, knownType) {
           case 'string': return `typeof ${v}==='string'`
           case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
           case 'integer': return `Number.isInteger(${v})`
-          case 'boolean': return `typeof ${v}==='boolean'`
+          case 'boolean': return `(${v}===true||${v}===false)`
           case 'null': return `${v}===null`
           default: return 'true'
         }
@@ -656,27 +681,19 @@ function genCode(schema, v, lines, ctx, knownType) {
   // Collect required keys so property checks can skip 'in' guard
   const requiredSet = new Set(schema.required || [])
 
-  // required + property hoisting via destructuring.
-  // V8 TurboFan optimizes destructuring into a single batch hidden-class-aware read.
-  // `d.key !== undefined` is faster than `'key' in d` (no prototype chain walk).
-  const hoisted = {} // key -> local var name
+  // required: skip explicit check if property has a type constraint
+  // (type check on undefined returns false anyway: Number.isInteger(undefined) === false)
+  const hoisted = {} // key -> access expression
   if (schema.required && schema.properties && isObj) {
-    const destructKeys = []
     const reqChecks = []
     for (const key of schema.required) {
-      if (schema.properties[key]) {
-        const localVar = `_h${ctx.varCounter++}`
-        hoisted[key] = localVar
-        destructKeys.push(`${JSON.stringify(key)}:${localVar}`)
-        reqChecks.push(`${localVar}===undefined`)
-      } else {
-        // Required but no property schema — just check existence
+      hoisted[key] = `${v}[${JSON.stringify(key)}]`
+      const prop = schema.properties[key]
+      const hasTypeCheck = prop && (prop.type || prop.enum || prop.const !== undefined)
+      if (!hasTypeCheck) {
         reqChecks.push(`${v}[${JSON.stringify(key)}]===undefined`)
       }
     }
-    if (destructKeys.length > 0) {
-      lines.push(`const{${destructKeys.join(',')}}=${v}`)
-    }
     if (reqChecks.length > 0) {
       lines.push(`if(${reqChecks.join('||')})return false`)
     }
@@ -738,12 +755,21 @@ function genCode(schema, v, lines, ctx, knownType) {
     lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
   }
 
-  // additionalProperties
+  // additionalProperties -- deferred to end of function for better V8 optimization
+  // (type checks run first in hot path, expensive prop count check last)
   if (schema.additionalProperties === false && schema.properties) {
-    const allowed = Object.keys(schema.properties).map(k => `'${esc(k)}'`).join(',')
-    const ci = ctx.varCounter++
-    const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i]))return false`
-    lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+    const propCount = Object.keys(schema.properties).length
+    if (!schema.patternProperties) {
+      const inner = `var _n=0;for(var _k in ${v})_n++;if(_n!==${propCount})return false`
+      if (!ctx.deferredChecks) ctx.deferredChecks = []
+      ctx.deferredChecks.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+    } else {
+      const allowed = Object.keys(schema.properties).map(k => `'${esc(k)}'`).join(',')
+      const ci = ctx.varCounter++
+      const inner = `const _k${ci}=Object.keys(${v});const _a${ci}=new Set([${allowed}]);for(let _i=0;_i<_k${ci}.length;_i++)if(!_a${ci}.has(_k${ci}[_i]))return false`
+      if (!ctx.deferredChecks) ctx.deferredChecks = []
+      ctx.deferredChecks.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+    }
   }
 
   // dependentRequired
@@ -973,7 +999,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx) {
         case 'string': return `typeof ${v}==='string'`
         case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
         case 'integer': return `Number.isInteger(${v})`
-        case 'boolean': return `typeof ${v}==='boolean'`
+        case 'boolean': return `(${v}===true||${v}===false)`
         case 'null': return `${v}===null`
         default: return 'true'
       }
@@ -1300,7 +1326,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
         case 'string': return `typeof ${v}==='string'`
         case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
         case 'integer': return `Number.isInteger(${v})`
-        case 'boolean': return `typeof ${v}==='boolean'`
+        case 'boolean': return `(${v}===true||${v}===false)`
         case 'null': return `${v}===null`
         default: return 'true'
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "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",
@@ -63,6 +63,7 @@
     "node-gyp-build": "^4.8.4"
   },
   "devDependencies": {
+    "@sinclair/typebox": "^0.34.49",
     "node-gyp": "^11.0.0",
     "prebuildify": "^6.0.1"
   },