ata-validator 0.4.4 → 0.4.6

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)** | 9.6M ops/sec | 8.5M ops/sec | **ata 1.1x faster** |
-| **isValidObject(obj)** | 10.4M ops/sec | 9.3M ops/sec | **ata 1.1x faster** |
-| **validateJSON(str)** | 1.9M ops/sec | 1.87M ops/sec | **ata 1.02x faster** |
-| **isValidJSON(str)** | 1.9M ops/sec | 1.89M ops/sec | **ata 1.01x 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
 
@@ -24,61 +25,57 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 | 100 users (20KB) | 658K ops/sec | 243K ops/sec | **ata 2.7x faster** |
 | 1,000 users (205KB) | 64K ops/sec | 23.5K ops/sec | **ata 2.7x faster** |
 
-### Parallel Batch Validation (multi-core)
-
-| Batch Size | ata | ajv | |
-|---|---|---|---|
-| 1,000 items | 8.4M items/sec | 2.2M items/sec | **ata 3.9x faster** |
-| 10,000 items | 12.5M items/sec | 2.1M items/sec | **ata 5.9x faster** |
-
-> ajv is single-threaded (JS). ata uses all CPU cores via a persistent C++ thread pool.
-
-### Where ajv wins
+### Real-World Scenarios
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** (invalid data, error collection) | 133K ops/sec | 7.5M ops/sec | **ajv 56x faster** |
-| **validateJSON(str)** (invalid data) | 169K ops/sec | 2.3M ops/sec | **ajv 14x faster** |
+| **Serverless cold start** (50 schemas) | 7.7ms | 96ms | **ata 12.5x 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** |
 
-> Invalid-data error collection goes through the C++ NAPI path. This is the slow path by design — 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 C++ engine for detailed error collection.
+**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`, `minimum/maximum`, `minLength/maxLength`, `pattern`, `format`.
+**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`.
 
-**V8 TurboFan optimizations**: Destructuring batch reads, `undefined` checks instead of `in` operator, context-aware type guard elimination, property hoisting to local variables.
+**V8 TurboFan optimizations**: Destructuring batch reads, `undefined` checks instead of `in` operator, context-aware type guard elimination, property hoisting to local variables, tiered uniqueItems (nested loop for small arrays).
 
 **Adaptive simdjson**: For large documents (>8KB) with selective schemas, simdjson On Demand seeks only the needed fields — skipping irrelevant data at GB/s speeds.
 
 ### JSON Schema Test Suite
 
-**98.5%** pass rate (938/952) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
+**98.4%** pass rate (937/952) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
 
 ## When to use ata
 
-- **Any `validate(obj)` workload** — 1.1x–2.7x faster than ajv on valid data
-- **Batch/streaming validation** — NDJSON log processing, data pipelines (5.9x faster)
-- **Schema-heavy startup** — many schemas compiled at boot (151x faster compile)
+- **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)
+- **Standard Schema V1** — native support for Fastify v5, tRPC, TanStack
 - **C/C++ embedding** — native library, no JS runtime needed
 
 ## When to use ajv
 
-- **Error-heavy workloads** — where most data is invalid and error details matter
-- **Schemas with `$ref`, `patternProperties`, `dependentSchemas`** — these bypass JS codegen and hit the slower NAPI path
+- **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
-- **Multi-core**: Parallel validation across all CPU cores — 12.5M validations/sec
+- **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
+- **RE2 regex**: Linear-time guarantees, immune to ReDoS attacks (2391x faster on pathological input)
 - **V8-optimized codegen**: Destructuring batch reads, type guard elimination, property hoisting
 - **Standard Schema V1**: Compatible with Fastify, tRPC, TanStack, Drizzle
 - **Zero-copy paths**: Buffer and pre-padded input support — no unnecessary copies
+- **Defaults + coercion**: `default` values, `coerceTypes`, `removeAdditional` support
 - **C/C++ library**: Native API for non-Node.js environments
-- **98.5% spec compliant**: Draft 2020-12
+- **98.4% spec compliant**: Draft 2020-12
 
 ## Installation
 
@@ -98,18 +95,18 @@ const v = new Validator({
   properties: {
     name: { type: 'string', minLength: 1 },
     email: { type: 'string', format: 'email' },
-    age: { type: 'integer', minimum: 0 }
+    age: { type: 'integer', minimum: 0 },
+    role: { type: 'string', default: 'user' }
   },
   required: ['name', 'email']
 });
 
-// Fast boolean check — JS codegen, no NAPI (1.1x 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
-const result = v.validate({ name: 'Mert', email: 'mert@example.com', age: 26 });
-console.log(result.valid); // true
-console.log(result.errors); // []
+// Full validation with error details + defaults applied
+const result = v.validate({ name: 'Mert', email: 'mert@example.com' });
+// result.valid === true, data.role === 'user' (default applied)
 
 // JSON string validation (simdjson fast path)
 v.validateJSON('{"name": "Mert", "email": "mert@example.com"}');
@@ -118,12 +115,21 @@ v.isValidJSON('{"name": "Mert", "email": "mert@example.com"}'); // true
 // Buffer input (zero-copy, raw NAPI)
 v.isValid(Buffer.from('{"name": "Mert", "email": "mert@example.com"}'));
 
-// Parallel batch — multi-core, NDJSON (5.9x faster than ajv)
+// Parallel batch — multi-core, NDJSON (2.6x faster than ajv)
 const ndjson = Buffer.from(lines.join('\n'));
 v.isValidParallel(ndjson);  // bool[]
 v.countValid(ndjson);        // number
 ```
 
+### Options
+
+```javascript
+const v = new Validator(schema, {
+  coerceTypes: true,       // "42" → 42 for integer fields
+  removeAdditional: true,  // strip properties not in schema
+});
+```
+
 ### Standard Schema V1
 
 ```javascript
@@ -143,7 +149,10 @@ npm install fastify-ata
 
 ```javascript
 const fastify = require('fastify')();
-fastify.register(require('fastify-ata'));
+fastify.register(require('fastify-ata'), {
+  coerceTypes: true,
+  removeAdditional: true,
+});
 
 // All existing JSON Schema route definitions work as-is
 ```

package/index.js

@@ -250,17 +250,24 @@ class Validator {
     const useSimdjsonForLarge = !hasArrayTraversal;
 
     if (jsFn) {
-      // Error handler: combined (optimized) → jsErrFn → NAPI fallback
-      const errFn = jsCombinedFn
-        ? (d) => { try { return jsCombinedFn(d); } catch { return compiled.validate(d); } }
-        : jsErrFn
-          ? (d) => { try { return jsErrFn(d, true); } catch { return compiled.validate(d); } }
-          : (d) => compiled.validate(d);
-      this.validate = preprocess
-        ? (data) => { preprocess(data); return jsFn(data) ? VALID_RESULT : errFn(data); }
-        : (data) => jsFn(data) ? VALID_RESULT : errFn(data);
+      // Best path: combined validator (single pass, lazy error array)
+      // 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); } })
+        : (preprocess
+            ? (data) => { preprocess(data); return jsFn(data) ? VALID_RESULT : errFn(data); }
+            : (data) => jsFn(data) ? VALID_RESULT : errFn(data));
       this.isValidObject = jsFn;
-      const jsonValidateFn = (obj) => jsFn(obj) ? VALID_RESULT : errFn(obj);
+      const jsonValidateFn = jsCombinedFn
+        ? (obj) => { try { return jsCombinedFn(obj); } catch { return jsFn(obj) ? VALID_RESULT : errFn(obj); } }
+        : (obj) => jsFn(obj) ? VALID_RESULT : errFn(obj);
       this.validateJSON = useSimdjsonForLarge
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {

package/lib/js-compiler.js

@@ -1208,16 +1208,18 @@ function compileToJSCombined(schema, VALID_RESULT) {
 
   // Use factory pattern: closure vars (regexes, etc.) created once, not per call
   const closureParams = ctx.closureVars.join(',')
-  const inner = `const _e=[];\n  ` +
+  // Lazy error array — no allocation for valid data (the common case)
+  const inner = `let _e;\n  ` +
     (ctx.helperCode.length ? ctx.helperCode.join('\n  ') + '\n  ' : '') +
     lines.join('\n  ') +
-    `\n  return _e.length===0?R:{valid:false,errors:_e}`
+    `\n  return _e?{valid:false,errors:_e}:R`
 
   try {
     const factory = new Function('R' + (closureParams ? ',' + closureParams : ''),
       `return function(d){${inner}}`)
     return factory(VALID_RESULT, ...ctx.closureVals)
-  } catch {
+  } catch (e) {
+    if (process.env.ATA_DEBUG) console.error('compileToJSCombined error:', e.message, '\n', inner.slice(0, 500))
     return null
   }
 }
@@ -1239,7 +1241,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   const types = schema.type ? (Array.isArray(schema.type) ? schema.type : [schema.type]) : null
   let isObj = false, isArr = false, isStr = false, isNum = false
 
-  const fail = (code, msg) => `_e.push({code:'${code}',path:${pathExpr||'""'},message:${msg}})`
+  const fail = (code, msg) => `(_e||(_e=[])).push({code:'${code}',path:${pathExpr||'""'},message:${msg}})`
 
   if (types) {
     const conds = types.map(t => {
@@ -1267,8 +1269,6 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
       isNum = types[0] === 'number' || types[0] === 'integer'
     }
     lines.push(`if(${typeOk}){`)
-    // We'll close this block at the end of genCodeC — mark it
-    ctx._typeBlock = true
   }
 
   // enum
@@ -1311,7 +1311,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     for (const key of schema.required) {
       const check = hoisted[key] ? `${hoisted[key]}===undefined` : `${v}[${JSON.stringify(key)}]===undefined`
       const p = pathExpr ? `${pathExpr}+'/${esc(key)}'` : `'/${esc(key)}'`
-      lines.push(`if(${check}){${`_e.push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})`}}`)
+      lines.push(`if(${check}){${`(_e||(_e=[])).push({code:'required_missing',path:${p},message:'missing: ${esc(key)}'})`}}`)
     }
   } else if (schema.required) {
     for (const key of schema.required) {
@@ -1383,7 +1383,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
       for (const dep of deps) {
         const p = pathExpr ? `${pathExpr}+'/${esc(dep)}'` : `'/${esc(dep)}'`
-        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){_e.push({code:'required_missing',path:${p},message:'${esc(key)} requires ${esc(dep)}'})}`)
+        lines.push(`if(typeof ${v}==='object'&&${v}!==null&&${JSON.stringify(key)} in ${v}&&!(${JSON.stringify(dep)} in ${v})){(_e||(_e=[])).push({code:'required_missing',path:${p},message:'${esc(key)} requires ${esc(dep)}'})}`)
       }
     }
   }
@@ -1482,9 +1482,8 @@ function genCodeC(schema, v, pathExpr, lines, ctx) {
   }
 
   // Close type-success block if opened
-  if (ctx._typeBlock) {
+  if (types) {
     lines.push(`}`)
-    ctx._typeBlock = false
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "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",