ata-validator 0.5.1 → 0.6.0

package/README.md

@@ -10,19 +10,19 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 29ns | 109ns | **ata 3.8x faster** |
-| **validate(obj)** invalid | 57ns | 191ns | **ata 3.3x faster** |
-| **isValidObject(obj)** | 28ns | 109ns | **ata 3.9x faster** |
-| **Schema compilation** | 665ns | 1.38ms | **ata 2,075x faster** |
-| **First validation** | 2.52μs | 1.16ms | **ata 460x faster** |
+| **validate(obj)** valid | 22ns | 102ns | **ata 4.6x faster** |
+| **validate(obj)** invalid | 87ns | 182ns | **ata 2.1x faster** |
+| **isValidObject(obj)** | 21ns | 100ns | **ata 4.7x faster** |
+| **Schema compilation** | 695ns | 1.30ms | **ata 1,867x faster** |
+| **First validation** | 2.07μs | 1.11ms | **ata 534x faster** |
 
 ### Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **validate(obj)** valid | 17ns | 116ns | **ata 6.8x faster** |
-| **validate(obj)** invalid | 58ns | 194ns | **ata 3.3x faster** |
-| **isValidObject(obj)** | 18ns | 119ns | **ata 6.5x faster** |
+| **validate(obj)** valid | 17ns | 115ns | **ata 6.8x faster** |
+| **validate(obj)** invalid | 59ns | 194ns | **ata 3.3x faster** |
+| **isValidObject(obj)** | 19ns | 124ns | **ata 6.6x faster** |
 
 ### Cross-Schema `$ref` (multi-schema with `$id` registry)
 
@@ -52,10 +52,10 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 | Scenario | ata | ajv | typebox | zod | valibot |
 |---|---|---|---|---|---|
-| **validate (valid)** | **9ns** | 39ns | 50ns | 339ns | 322ns |
-| **validate (invalid)** | **38ns** | 107ns | 4ns | 12.0μs | 840ns |
-| **compilation** | **556ns** | 1.24ms | 54μs | — | — |
-| **first validation** | **2.0μs** | 1.16ms | 55μs | — | — |
+| **validate (valid)** | **9ns** | 38ns | 50ns | 334ns | 326ns |
+| **validate (invalid)** | **37ns** | 103ns | 4ns | 11.8μs | 842ns |
+| **compilation** | **584ns** | 1.20ms | 52μs | — | — |
+| **first validation** | **2.1μs** | 1.11ms | 54μs | — | — |
 
 > Different categories: ata/ajv/typebox are JSON Schema validators, zod/valibot are schema-builder DSLs. [Benchmark code](benchmark/bench_all_mitata.mjs)
 
@@ -71,7 +71,7 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 | Scenario | ata | ajv | |
 |---|---|---|---|
-| **Serverless cold start** (50 schemas) | 0.1ms | 23ms | **ata 242x faster** |
+| **Serverless cold start** (50 schemas) | 0.1ms | 23ms | **ata 230x 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 startup** (5 routes) | 0.5ms | 6.0ms | **ata 12x faster** |

package/binding/ata_napi.cpp

@@ -1040,24 +1040,31 @@ static ThreadPool& pool() {
 }
 
 // --- Fast Validation Registry ---
-// Global schema slots for V8 Fast API (bypasses NAPI overhead)
+// Global schema slots for pre-compiled validation (bypasses per-call compilation)
 static constexpr size_t MAX_FAST_SLOTS = 4096;
 static ata::schema_ref g_fast_schemas[MAX_FAST_SLOTS];
 static std::string g_fast_schema_jsons[MAX_FAST_SLOTS];
 static uint32_t g_fast_slot_count = 0;
 
-// Register a compiled schema in a fast slot, returns slot ID
+// Register a compiled schema in a fast slot, returns slot ID.
+// Deduplicates: same schema JSON string returns existing slot.
 Napi::Value FastRegister(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (info.Length() < 1 || !info[0].IsString()) {
     Napi::TypeError::New(env, "Schema JSON string expected").ThrowAsJavaScriptException();
     return env.Undefined();
   }
+  std::string schema_json = info[0].As<Napi::String>().Utf8Value();
+  // Deduplicate: return existing slot for identical schema JSON
+  for (uint32_t i = 0; i < g_fast_slot_count; i++) {
+    if (g_fast_schema_jsons[i] == schema_json) {
+      return Napi::Number::New(env, i);
+    }
+  }
   if (g_fast_slot_count >= MAX_FAST_SLOTS) {
     Napi::Error::New(env, "Max fast schema slots reached").ThrowAsJavaScriptException();
     return env.Undefined();
   }
-  std::string schema_json = info[0].As<Napi::String>().Utf8Value();
   auto schema = ata::compile(schema_json);
   if (!schema) {
     Napi::Error::New(env, "Failed to compile schema").ThrowAsJavaScriptException();
@@ -1069,12 +1076,11 @@ Napi::Value FastRegister(const Napi::CallbackInfo& info) {
   return Napi::Number::New(env, slot);
 }
 
-// Fast validation: slot + Uint8Array → bool (called via V8 Fast API)
+// Fast validation: slot + raw buffer → bool
+// Routes through is_valid_buf → is_valid_prepadded → On-Demand od_plan fast path
 static bool FastValidateImpl(uint32_t slot, const uint8_t* data, size_t length) {
   if (slot >= g_fast_slot_count) return false;
-  auto result = ata::validate(g_fast_schemas[slot],
-                               std::string_view(reinterpret_cast<const char*>(data), length));
-  return result.valid;
+  return ata::is_valid_buf(g_fast_schemas[slot], data, length);
 }
 
 // Zero-copy validation with pre-padded buffer

package/compat.js

@@ -10,15 +10,7 @@ class Ata {
     const v = new Validator(schema);
     const validate = (data) => {
       const result = v.validate(data);
-      validate.errors = result.valid
-        ? null
-        : result.errors.map((e) => ({
-            instancePath: e.path ? "/" + e.path.replace(/\//g, "/") : "",
-            schemaPath: "",
-            keyword: "",
-            params: {},
-            message: e.message,
-          }));
+      validate.errors = result.valid ? null : result.errors;
       return result.valid;
     };
     validate.errors = null;

package/include/ata.h

@@ -91,6 +91,10 @@ validation_result validate(std::string_view schema_json,
 // Use this when you only need true/false and can provide pre-padded input.
 bool is_valid_prepadded(const schema_ref& schema, const char* data, size_t length);
 
+// Validate raw buffer — handles padding internally via thread-local copy.
+// Use this when input doesn't have simdjson padding (e.g., from V8 TypedArray).
+bool is_valid_buf(const schema_ref& schema, const uint8_t* data, size_t length);
+
 // Required padding size for is_valid_prepadded
 inline constexpr size_t REQUIRED_PADDING = 64;
 

package/index.d.ts

@@ -1,6 +1,8 @@
 export interface ValidationError {
-  code: string;
-  path: string;
+  keyword: string;
+  instancePath: string;
+  schemaPath: string;
+  params: Record<string, unknown>;
   message: string;
 }
 
@@ -43,8 +45,14 @@ export class Validator {
   /** Fast boolean check for JSON string */
   isValidJSON(jsonString: string): boolean;
 
-  /** Validate Buffer/Uint8Array — raw NAPI fast path */
-  isValid(input: Buffer | Uint8Array): boolean;
+  /** Ultra-fast buffer validation via V8 CFunction — zero NAPI overhead */
+  isValid(input: Buffer | Uint8Array | string): boolean;
+
+  /** Count valid documents in an NDJSON buffer */
+  countValid(ndjsonBuf: Buffer | Uint8Array | string): number;
+
+  /** Count valid documents from an array of buffers */
+  batchIsValid(buffers: (Buffer | Uint8Array)[]): number;
 
   /** Zero-copy validation with pre-padded buffer */
   isValidPrepadded(paddedBuffer: Buffer, jsonLength: number): boolean;

package/index.js

@@ -1,4 +1,7 @@
-const native = require("node-gyp-build")(__dirname);
+// Native addon: optional. Core validate() uses JS codegen and works without it.
+// Buffer APIs (isValid, countValid, isValidParallel) require native.
+let native;
+try { native = require("node-gyp-build")(__dirname); } catch {}
 const {
   compileToJS,
   compileToJSCodegen,
@@ -346,6 +349,21 @@ class Validator {
       this._ensureCompiled();
       return this.isValidJSON(jsonStr);
     };
+    this.isValid = (buf) => {
+      if (!native) throw new Error('Native addon required for isValid() — use validate() or isValidObject() instead');
+      this._ensureCompiled();
+      return this.isValid(buf);
+    };
+    this.countValid = (ndjsonBuf) => {
+      if (!native) throw new Error('Native addon required for countValid()');
+      this._ensureCompiled();
+      return this.countValid(ndjsonBuf);
+    };
+    this.batchIsValid = (buffers) => {
+      if (!native) throw new Error('Native addon required for batchIsValid()');
+      this._ensureCompiled();
+      return this.batchIsValid(buffers);
+    };
 
     // ~standard uses self.validate() -- works with lazy because it goes through
     // the instance property which gets swapped after compilation
@@ -362,7 +380,7 @@ class Validator {
           return {
             issues: result.errors.map((err) => ({
               message: err.message,
-              path: parsePointerPath(err.path),
+              path: parsePointerPath(err.instancePath),
             })),
           };
         },
@@ -521,7 +539,7 @@ class Validator {
       const jsonValidateFn = safeCombinedFn
         || hybridFn
         || ((obj) => (jsFn(obj) ? VALID_RESULT : errFn(obj)));
-      this.validateJSON = useSimdjsonForLarge
+      this.validateJSON = useSimdjsonForLarge && native
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
               this._ensureNative();
@@ -543,11 +561,12 @@ class Validator {
               return jsonValidateFn(JSON.parse(jsonStr));
             } catch (e) {
               if (!(e instanceof SyntaxError)) throw e;
+              if (!native) return { valid: false, errors: [{ keyword: 'syntax', instancePath: '', schemaPath: '#', params: {}, message: e.message }] };
             }
             this._ensureNative();
             return this._compiled.validateJSON(jsonStr);
           };
-      this.isValidJSON = useSimdjsonForLarge
+      this.isValidJSON = useSimdjsonForLarge && native
         ? (jsonStr) => {
             if (jsonStr.length >= SIMDJSON_THRESHOLD) {
               this._ensureNative();
@@ -571,7 +590,30 @@ class Validator {
               return false;
             }
           };
-    } else {
+      // Buffer APIs: lazy native init — only compile native schema on first buffer call.
+      // This keeps cold start fast (JS codegen only) for users who only use validate().
+      if (native) {
+        const self = this;
+        this.isValid = (buf) => {
+          self._ensureNative();
+          const slot = self._fastSlot;
+          self.isValid = (b) => { if (typeof b === 'string') b = Buffer.from(b); return native.rawFastValidate(slot, b); };
+          return self.isValid(buf);
+        };
+        this.countValid = (ndjsonBuf) => {
+          self._ensureNative();
+          const slot = self._fastSlot;
+          self.countValid = (b) => { if (typeof b === 'string') b = Buffer.from(b); const r = native.rawNDJSONValidate(slot, b); let c = 0; for (let i = 0; i < r.length; i++) if (r[i]) c++; return c; };
+          return self.countValid(ndjsonBuf);
+        };
+        this.batchIsValid = (buffers) => {
+          self._ensureNative();
+          const slot = self._fastSlot;
+          self.batchIsValid = (bufs) => { let v = 0; for (const b of bufs) if (native.rawFastValidate(slot, b)) v++; return v; };
+          return self.batchIsValid(buffers);
+        };
+      }
+    } else if (native) {
       // ATA_FORCE_NAPI path: no JS codegen, use native for everything
       this._ensureNative();
       this.validate = preprocess
@@ -583,12 +625,40 @@ class Validator {
       this.isValidObject = (data) => this._compiled.validate(data).valid;
       this.validateJSON = (jsonStr) => this._compiled.validateJSON(jsonStr);
       this.isValidJSON = (jsonStr) => this._compiled.isValidJSON(jsonStr);
+      {
+        const slot = this._fastSlot;
+        this.isValid = (buf) => {
+          if (typeof buf === 'string') buf = Buffer.from(buf);
+          return native.rawFastValidate(slot, buf);
+        };
+      }
+      {
+        const slot = this._fastSlot;
+        this.countValid = (ndjsonBuf) => {
+          if (typeof ndjsonBuf === 'string') ndjsonBuf = Buffer.from(ndjsonBuf);
+          const results = native.rawNDJSONValidate(slot, ndjsonBuf);
+          let count = 0;
+          for (let i = 0; i < results.length; i++) if (results[i]) count++;
+          return count;
+        };
+      }
+      {
+        const slot = this._fastSlot;
+        this.batchIsValid = (buffers) => {
+          let valid = 0;
+          for (const buf of buffers) {
+            if (native.rawFastValidate(slot, buf)) valid++;
+          }
+          return valid;
+        };
+      }
     }
   }
 
   _ensureNative() {
     if (this._nativeReady) return;
     this._nativeReady = true;
+    if (!native) return;
     let nativeSchemaStr = this._schemaStr;
     if (this._schemaMap.size > 0) {
       const merged = JSON.parse(this._schemaStr);
@@ -770,7 +840,7 @@ module.exports = { boolFn, hybridFactory, errFn };
           return {
             issues: result.errors.map((e) => ({
               message: e.message,
-              path: parsePointerPath(e.path),
+              path: parsePointerPath(e.instancePath),
             })),
           };
         },
@@ -785,43 +855,54 @@ module.exports = { boolFn, hybridFactory, errFn };
 
   // Raw NAPI fast path for Buffer/Uint8Array
   isValid(input) {
+    if (!native) throw new Error('Native addon required for isValid() — install build tools or use validate() instead');
     this._ensureNative();
     return native.rawFastValidate(this._fastSlot, input);
   }
 
   // Zero-copy pre-padded path
   isValidPrepadded(paddedBuffer, jsonLength) {
+    if (!native) throw new Error('Native addon required for isValidPrepadded()');
     this._ensureNative();
     return native.rawFastValidate(this._fastSlot, paddedBuffer, jsonLength);
   }
 
   // Parallel NDJSON batch (multi-core)
   isValidParallel(buffer) {
+    if (!native) throw new Error('Native addon required for isValidParallel()');
     this._ensureNative();
     return native.rawParallelValidate(this._fastSlot, buffer);
   }
 
   // Parallel count (fastest -- single uint32 return)
   countValid(buffer) {
+    if (!native) throw new Error('Native addon required for countValid()');
     this._ensureNative();
     return native.rawParallelCount(this._fastSlot, buffer);
   }
 
   // NDJSON single-thread batch
   isValidNDJSON(buffer) {
+    if (!native) throw new Error('Native addon required for isValidNDJSON()');
     this._ensureNative();
     return native.rawNDJSONValidate(this._fastSlot, buffer);
   }
 }
 
 function validate(schema, data) {
-  const schemaStr =
-    typeof schema === "string" ? schema : JSON.stringify(schema);
-  return native.validate(schemaStr, data);
+  if (native) {
+    const schemaStr =
+      typeof schema === "string" ? schema : JSON.stringify(schema);
+    return native.validate(schemaStr, data);
+  }
+  // JS fallback: compile and validate
+  const v = new Validator(typeof schema === "string" ? JSON.parse(schema) : schema);
+  return v.validate(data);
 }
 
 function version() {
-  return native.version();
+  if (native) return native.version();
+  return require("./package.json").version;
 }
 
 // Bundle multiple validators into a single JS file for fast startup.