ata-validator

Ultra-fast JSON Schema validator powered by simdjson. Multi-core parallel validation, RE2 regex, codegen bytecode engine. Standard Schema V1 compatible.

ata-validator.com | API Docs | Contributing

Performance

Simple Schema (7 properties, type + format + range + nested object)

Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)

Cross-Schema $ref (multi-schema with $id registry)

Measured with mitata on Apple M4 Pro (process-isolated). Benchmark code

unevaluatedProperties / unevaluatedItems

Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, dynamic schemas (anyOf/oneOf) use bitmask tracking with V8-inlined branch functions. Benchmark code

vs Ecosystem (Zod, Valibot, TypeBox)

Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. Benchmark code

Large Data - JS Object Validation

Real-World Scenarios

Isolated single-schema benchmarks. Results vary by workload and hardware.

How it works

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 with pre-allocated frozen error objects - 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). Full keyword support including patternProperties, dependentSchemas, propertyNames, unevaluatedProperties, unevaluatedItems, cross-schema $ref with $id registry, and Draft 7 auto-detection. Three-tier hybrid approach for unevaluated keywords: compile-time resolution for static schemas, bitmask tracking for dynamic ones. charCodeAt prefix matching replaces regex for simple patterns (4x faster). Merged key iteration loops (patternProperties + propertyNames + additionalProperties in a single for..in).

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), inline key comparison for small property sets (no Set.has overhead).

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

96.9% pass rate (1109/1144) on official JSON Schema Test Suite (Draft 2020-12).

When to use ata

• High-throughput validate(obj) - 6.8x faster than ajv on complex schemas, 38x faster than zod
• Complex schemas - patternProperties, dependentSchemas, propertyNames, unevaluatedProperties all inline JS codegen (6.8x faster than ajv)
• Multi-schema projects - cross-schema $ref with $id registry, addSchema() API
• Draft 7 migration - auto-detects $schema, normalizes Draft 7 keywords transparently
• Serverless / cold starts - 6,904x faster compilation, 5,148x 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
• C/C++ embedding - native library, no JS runtime needed

When to use ajv

• 100% spec compliance needed - ajv covers more edge cases (ata: 96.9%)
• $dynamicRef - not yet supported in ata

Features

• Hybrid validator: 6.8x faster than ajv valid, 6.0x faster invalid on complex schemas - jsFn boolean guard for valid path (zero allocation), combined codegen with pre-allocated errors for invalid path. Schema compilation cache for repeated schemas
• Cross-schema $ref: schemas option and addSchema() API. Compile-time resolution with $id registry, zero runtime overhead
• Draft 7 support: Auto-detects $schema field, normalizes dependencies/additionalItems/definitions transparently
• 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)
• 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
• 96.9% spec compliant: Draft 2020-12

Installation

npm install ata-validator

Usage

Node.js

const { Validator } = require('ata-validator');

const v = new Validator({
  type: 'object',
  properties: {
    name: { type: 'string', minLength: 1 },
    email: { type: 'string', format: 'email' },
    age: { type: 'integer', minimum: 0 },
    role: { type: 'string', default: 'user' }
  },
  required: ['name', 'email']
});

// 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
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"}');
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, 13.4M items/sec
const ndjson = Buffer.from(lines.join('\n'));
v.isValidParallel(ndjson);  // bool[]
v.countValid(ndjson);        // number

Cross-Schema $ref

const addressSchema = {
  $id: 'https://example.com/address',
  type: 'object',
  properties: { street: { type: 'string' }, city: { type: 'string' } },
  required: ['street', 'city']
};

const v = new Validator({
  type: 'object',
  properties: {
    name: { type: 'string' },
    address: { $ref: 'https://example.com/address' }
  }
}, { schemas: [addressSchema] });

// Or use addSchema()
const v2 = new Validator(mainSchema);
v2.addSchema(addressSchema);

Options

const v = new Validator(schema, {
  coerceTypes: true,       // "42" → 42 for integer fields
  removeAdditional: true,  // strip properties not in schema
  schemas: [otherSchema],  // cross-schema $ref registry
});

Standalone Pre-compilation

Pre-compile schemas to JS files for near-zero startup. No native addon needed at runtime.

const fs = require('fs');

// Build phase (once)
const v = new Validator(schema);
fs.writeFileSync('./compiled.js', v.toStandalone());

// Read phase (every startup) - 0.6μs per schema, pure JS
const v2 = Validator.fromStandalone(require('./compiled.js'), schema);

// Bundle multiple schemas - deduplicated, single file
fs.writeFileSync('./bundle.js', Validator.bundleCompact(schemas));
const validators = Validator.loadBundle(require('./bundle.js'), schemas);

Fastify startup (5 routes): ajv 6.0ms → ata 0.5ms (12x faster, no build step needed)

Standard Schema V1

const v = new Validator(schema);

// Works with Fastify, tRPC, TanStack, etc.
const result = v['~standard'].validate(data);
// { value: data } on success
// { issues: [{ message, path }] } on failure

Fastify Plugin

npm install fastify-ata

const fastify = require('fastify')();
fastify.register(require('fastify-ata'), {
  coerceTypes: true,
  removeAdditional: true,
});

// All existing JSON Schema route definitions work as-is

C++

#include "ata.h"

auto schema = ata::compile(R"({
  "type": "object",
  "properties": { "name": {"type": "string"} },
  "required": ["name"]
})");

auto result = ata::validate(schema, R"({"name": "Mert"})");
// result.valid == true

Supported Keywords

Format Validators (hand-written, no regex)

email, date, date-time, time, uri, uri-reference, ipv4, ipv6, uuid, hostname

Building from Source

Development prerequisites

Native builds require C/C++ toolchain support and the following libraries:

• re2
• abseil
• mimalloc

Install them before running npm install / npm run build:

# macOS (Homebrew)
brew install re2 abseil mimalloc

# Ubuntu/Debian (apt)
sudo apt-get update
sudo apt-get install -y libre2-dev libabsl-dev libmimalloc-dev

# C++ library + tests
cmake -B build
cmake --build build
./build/ata_tests

# Node.js addon
npm install
npm run build
npm test

# JSON Schema Test Suite
npm run test:suite

License

MIT

Authors

Mert Can Altin Daniel Lemire