ata-validator 0.4.13 → 0.4.15

package/README.md

@@ -2,7 +2,7 @@
 
 Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjson/simdjson). Multi-core parallel validation, RE2 regex, codegen bytecode engine. Standard Schema V1 compatible.
 
-**[ata-validator.com](https://ata-validator.com)**
+**[ata-validator.com](https://ata-validator.com)** | **[API Docs](docs/API.md)** | **[Contributing](CONTRIBUTING.md)**
 
 ## Performance
 
@@ -10,13 +10,24 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **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)** valid | 16.6M ops/sec | 9.8M ops/sec | **ata 1.7x faster** |
+| **validate(obj)** invalid | 10.0M ops/sec | 5.6M ops/sec | **ata 1.8x faster** |
+| **isValidObject(obj)** | 36.0M ops/sec | 9.4M ops/sec | **ata 3.8x faster** |
+| **Schema compilation** | 1.6M ops/sec | 781 ops/sec | **ata 2,067x faster** |
+| **First validation** | 614K ops/sec | 775 ops/sec | **ata 793x faster** |
 
-> validate(obj) numbers are isolated single-schema benchmarks. Multi-schema benchmark overhead reduces throughput; real-world numbers depend on workload.
+> Measured with [mitata](https://github.com/evanwashere/mitata) (process-isolated). Results vary by workload and hardware.
+
+### vs typebox 1.x (with format: 'email')
+
+| Scenario | ata | typebox | |
+|---|---|---|---|
+| **isValidObject(obj)** valid | 90.9M ops/sec | 18.2M ops/sec | **ata 5.0x faster** |
+| **isValidObject(obj)** invalid | 435M ops/sec | 169M ops/sec | **ata 2.6x faster** |
+| **Schema compilation** | 2.0M ops/sec | 18.5K ops/sec | **ata 110x faster** |
+| **First validation** | 1.55M ops/sec | 18.2K ops/sec | **ata 85x faster** |
+
+> typebox 1.x is JSON Schema compliant with RFC format support. [Benchmark code](benchmark/bench_vs_typebox_esm.mjs)
 
 ### Large Data - JS Object Validation
 
@@ -53,8 +64,8 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## When to use ata
 
-- **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
+- **High-throughput `validate(obj)`** - 16.6M ops/sec valid, 10.0M ops/sec invalid
+- **Serverless / cold starts** - 2,067x faster compilation, 793x 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
@@ -67,7 +78,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 ## Features
 
-- **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
+- **Hybrid validator**: 16.6M ops/sec valid, 10.0M 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)
@@ -234,6 +245,7 @@ npm run test:suite
 
 MIT
 
-## Author
+## Authors
 
 [Mert Can Altin](https://github.com/mertcanaltin)
+[Daniel Lemire](https://github.com/lemire)

package/lib/js-compiler.js

@@ -523,6 +523,11 @@ function compileToJSCodegen(schema) {
   genCode(schema, 'd', lines, ctx)
   if (lines.length === 0) return () => true
 
+  // Append deferred checks (additionalProperties) at the end
+  if (ctx.deferredChecks) {
+    for (const dc of ctx.deferredChecks) lines.push(dc)
+  }
+
   const checkStr = lines.join('\n  ')
 
   // Regex and helpers are passed as closure variables (not re-created per call)
@@ -634,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'
         }
@@ -676,13 +681,18 @@ function genCode(schema, v, lines, ctx, knownType) {
   // Collect required keys so property checks can skip 'in' guard
   const requiredSet = new Set(schema.required || [])
 
-  // required: direct property access (faster than destructuring in V8)
-  const hoisted = {} // key -> access expression (no local vars)
+  // 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 reqChecks = []
     for (const key of schema.required) {
       hoisted[key] = `${v}[${JSON.stringify(key)}]`
-      reqChecks.push(`${v}[${JSON.stringify(key)}]===undefined`)
+      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 (reqChecks.length > 0) {
       lines.push(`if(${reqChecks.join('||')})return false`)
@@ -745,18 +755,20 @@ 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 propCount = Object.keys(schema.properties).length
     if (!schema.patternProperties) {
-      // Fast path: known property count, just check length
-      const inner = `if(Object.getOwnPropertyNames(${v}).length!==${propCount})return false`
-      lines.push(isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+      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`
-      lines.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
+      if (!ctx.deferredChecks) ctx.deferredChecks = []
+      ctx.deferredChecks.push(isObj ? `{${inner}}` : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
     }
   }
 
@@ -987,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'
       }
@@ -1314,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.13",
+  "version": "0.4.15",
   "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",
@@ -64,8 +64,10 @@
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.34.49",
+    "mitata": "^1.0.34",
     "node-gyp": "^11.0.0",
-    "prebuildify": "^6.0.1"
+    "prebuildify": "^6.0.1",
+    "typebox": "^1.1.7"
   },
   "gypfile": true
 }