ata-validator 0.7.3 → 0.9.0

package/CMakeLists.txt

@@ -19,43 +19,48 @@ endif()
 option(ATA_TESTING "Build test suite" ON)
 option(ATA_BENCHMARKS "Build benchmarks" OFF)
 option(ATA_SANITIZE "Enable address sanitizer" OFF)
+option(ATA_NO_RE2 "Build without RE2 regex engine (disables pattern keyword)" OFF)
 
 # Fetch simdjson
 include(FetchContent)
 FetchContent_Declare(
   simdjson
   GIT_REPOSITORY https://github.com/simdjson/simdjson.git
-  GIT_TAG v3.12.2
+  GIT_TAG v4.5.0
   GIT_SHALLOW TRUE
 )
 
-# RE2 — fast regex engine (replaces std::regex)
-set(RE2_BUILD_TESTING OFF CACHE BOOL "" FORCE)
-FetchContent_Declare(
-  re2
-  GIT_REPOSITORY https://github.com/google/re2.git
-  GIT_TAG 2024-07-02
-  GIT_SHALLOW TRUE
-  EXCLUDE_FROM_ALL
-)
+if(NOT ATA_NO_RE2)
+  # RE2 — fast regex engine (replaces std::regex)
+  set(RE2_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+  FetchContent_Declare(
+    re2
+    GIT_REPOSITORY https://github.com/google/re2.git
+    GIT_TAG 2024-07-02
+    GIT_SHALLOW TRUE
+    EXCLUDE_FROM_ALL
+  )
 
-# Abseil — required by RE2
-set(ABSL_PROPAGATE_CXX_STD ON CACHE BOOL "" FORCE)
-set(ABSL_BUILD_TESTING OFF CACHE BOOL "" FORCE)
-set(ABSL_ENABLE_INSTALL ON CACHE BOOL "" FORCE)
-FetchContent_Declare(
-  abseil-cpp
-  GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
-  GIT_TAG 20240722.0
-  GIT_SHALLOW TRUE
-)
+  # Abseil — required by RE2
+  set(ABSL_PROPAGATE_CXX_STD ON CACHE BOOL "" FORCE)
+  set(ABSL_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+  set(ABSL_ENABLE_INSTALL ON CACHE BOOL "" FORCE)
+  FetchContent_Declare(
+    abseil-cpp
+    GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
+    GIT_TAG 20240722.0
+    GIT_SHALLOW TRUE
+  )
 
-FetchContent_MakeAvailable(abseil-cpp simdjson re2)
+  FetchContent_MakeAvailable(abseil-cpp simdjson re2)
+else()
+  FetchContent_MakeAvailable(simdjson)
+endif()
 
 if (CMAKE_JS_VERSION)
   # add_definitions(-DNAPI_VERSION=10)
   include_directories(${CMAKE_JS_INC})
-  file(GLOB SOURCE_FILES "binding/*.cpp" "src/*.cpp" "deps/simdjson/*.cpp")
+  file(GLOB SOURCE_FILES "binding/*.cpp" "src/*.cpp")
 else()
   file(GLOB SOURCE_FILES "src/*.cpp")
 endif()
@@ -88,7 +93,12 @@ else()
 endif()
 
 target_include_directories(${PROJECT_NAME} PUBLIC include)
-target_link_libraries(${PROJECT_NAME} PRIVATE simdjson re2)
+if(ATA_NO_RE2)
+  target_link_libraries(${PROJECT_NAME} PRIVATE simdjson)
+  target_compile_definitions(${PROJECT_NAME} PRIVATE ATA_NO_RE2)
+else()
+  target_link_libraries(${PROJECT_NAME} PRIVATE simdjson re2)
+endif()
 
 if (CMAKE_JS_VERSION)
   target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_JS_INC})
@@ -130,3 +140,11 @@ if(ATA_BENCHMARKS)
   add_executable(ata_bench benchmark/bench.cpp)
   target_link_libraries(ata_bench PRIVATE ata simdjson)
 endif()
+
+# Fuzz targets (for OSS-Fuzz / libFuzzer)
+if(ATA_FUZZING)
+  foreach(fuzzer compile_fuzzer validate_fuzzer roundtrip_fuzzer)
+    add_executable(${fuzzer} fuzz/${fuzzer}.cpp)
+    target_link_libraries(${fuzzer} PRIVATE ata simdjson ${LIB_FUZZING_ENGINE})
+  endforeach()
+endif()

package/README.md

@@ -13,7 +13,7 @@ Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjs
 | **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** |
+| **Schema compilation** | 453ns | 1.24ms | **ata 2,729x faster** |
 | **First validation** | 2.07μs | 1.11ms | **ata 534x faster** |
 
 ### Complex Schema (patternProperties + dependentSchemas + propertyNames + additionalProperties)
@@ -54,7 +54,7 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 |---|---|---|---|---|---|
 | **validate (valid)** | **9ns** | 38ns | 50ns | 334ns | 326ns |
 | **validate (invalid)** | **37ns** | 103ns | 4ns | 11.8μs | 842ns |
-| **compilation** | **584ns** | 1.20ms | 52μs | — | — |
+| **compilation** | **453ns** | 1.24ms | 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 230x faster** |
+| **Serverless cold start** (50 schemas) | 0.087ms | 3.67ms | **ata 42x 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** |
@@ -88,14 +88,26 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 **Adaptive simdjson**: For large documents (>8KB) with selective schemas, simdjson On Demand seeks only the needed fields - skipping irrelevant data at GB/s speeds.
 
+### $dynamicRef / $dynamicAnchor / $anchor
+
+| Scenario | ata | ajv | |
+|---|---|---|---|
+| **$dynamicRef tree** valid | 22ns | 54ns | **ata 2.4x faster** |
+| **$dynamicRef tree** invalid | 70ns | 76ns | **ata 1.1x faster** |
+| **$dynamicRef override** valid | 2.6ns | 183ns | **ata 70x faster** |
+| **$dynamicRef override** invalid | 48ns | 185ns | **ata 3.8x faster** |
+| **$anchor array** valid | 2.3ns | 3.1ns | **ata 1.4x faster** |
+
+Self-recursive named functions for $dynamicRef, compile-time cross-schema resolution, zero-wrapper hybrid path. [Benchmark code](benchmark/bench_dynamicref_vs_ajv.mjs)
+
 ### JSON Schema Test Suite
 
-**96.9%** pass rate (1109/1144) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12).
+**95.3%** pass rate (1170/1227) on official [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) (Draft 2020-12). **95.3%** on [@exodus/schemasafe](https://github.com/ExodusMovement/schemasafe) test suite.
 
 ## 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)
+- **High-throughput `validate(obj)`** - 3.1x faster than ajv, 38x faster than zod
+- **Complex schemas** - `patternProperties`, `dependentSchemas`, `propertyNames`, `unevaluatedProperties` all inline JS codegen
 - **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
@@ -106,12 +118,13 @@ Three-tier hybrid codegen: static schemas compile to zero-overhead key checks, d
 
 ## When to use ajv
 
-- **100% spec compliance needed** - ajv covers more edge cases (ata: 96.9%)
-- **`$dynamicRef`** - not yet supported in ata
+- **Existing ajv ecosystem** - plugins, custom keywords, large community
+- **Full unevaluatedProperties/Items** - ata covers most cases but some edge cases remain
 
 ## 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
+- **Hybrid validator**: 4.1x faster than ajv, up to 70x faster on $dynamicRef - zero-wrapper hybrid path for valid data (no allocation), combined codegen for error collection. Schema compilation cache for repeated schemas
+- **$dynamicRef / $dynamicAnchor / $anchor**: Full Draft 2020-12 dynamic reference support. Self-recursive named functions, compile-time cross-schema resolution (42/42 spec tests)
 - **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

package/binding/ata_napi.cpp

@@ -9,12 +9,15 @@
 #include <functional>
 #include <queue>
 #include <atomic>
+#ifndef ATA_NO_RE2
 #include <re2/re2.h>
+#endif
 #include <set>
 #include <string>
 #include <vector>
 
 #include "ata.h"
+#include <simdjson.h>
 
 // ============================================================================
 // V8 Direct Object Traversal Engine
@@ -39,7 +42,9 @@ struct schema_node {
   std::optional<uint64_t> min_length;
   std::optional<uint64_t> max_length;
   std::optional<std::string> pattern;
+#ifndef ATA_NO_RE2
   std::shared_ptr<re2::RE2> compiled_pattern;
+#endif
 
   std::optional<uint64_t> min_items;
   std::optional<uint64_t> max_items;
@@ -63,7 +68,9 @@ struct schema_node {
   struct pattern_prop {
     std::string pattern;
     schema_node_ptr schema;
+#ifndef ATA_NO_RE2
     std::shared_ptr<re2::RE2> compiled;
+#endif
   };
   std::vector<pattern_prop> pattern_properties;
 
@@ -83,6 +90,8 @@ struct schema_node {
   schema_node_ptr else_schema;
 
   std::string ref;
+  std::string dynamic_ref;
+  std::string id;
 
   std::unordered_map<std::string, schema_node_ptr> defs;
 
@@ -114,10 +123,14 @@ static bool napi_check_format(const std::string& sv, const std::string& fmt) {
            (sv.size() - dot - 1) >= 2;
   }
   if (fmt == "date") {
-    return sv.size() == 10 && nb_is_digit(sv[0]) && nb_is_digit(sv[1]) &&
-           nb_is_digit(sv[2]) && nb_is_digit(sv[3]) && sv[4] == '-' &&
-           nb_is_digit(sv[5]) && nb_is_digit(sv[6]) && sv[7] == '-' &&
-           nb_is_digit(sv[8]) && nb_is_digit(sv[9]);
+    if (sv.size() != 10 || !nb_is_digit(sv[0]) || !nb_is_digit(sv[1]) ||
+        !nb_is_digit(sv[2]) || !nb_is_digit(sv[3]) || sv[4] != '-' ||
+        !nb_is_digit(sv[5]) || !nb_is_digit(sv[6]) || sv[7] != '-' ||
+        !nb_is_digit(sv[8]) || !nb_is_digit(sv[9]))
+      return false;
+    int month = (sv[5] - '0') * 10 + (sv[6] - '0');
+    int day = (sv[8] - '0') * 10 + (sv[9] - '0');
+    return month >= 1 && month <= 12 && day >= 1 && day <= 31;
   }
   if (fmt == "time") {
     if (sv.size() < 8) return false;
@@ -286,6 +299,15 @@ static void validate_napi(const schema_node_ptr& node,
                            const compiled_schema_internal& ctx,
                            std::vector<ata::validation_error>& errors);
 
+// Recursion depth guard — prevents stack overflow on self-referencing schemas
+struct NapiDepthGuard {
+  static thread_local int depth;
+  bool overflow;
+  NapiDepthGuard() : overflow(++depth > 100) {}
+  ~NapiDepthGuard() { --depth; }
+};
+thread_local int NapiDepthGuard::depth = 0;
+
 static void validate_napi(const schema_node_ptr& node,
                            Napi::Value value,
                            Napi::Env env,
@@ -294,6 +316,9 @@ static void validate_napi(const schema_node_ptr& node,
                            std::vector<ata::validation_error>& errors) {
   if (!node) return;
 
+  NapiDepthGuard guard;
+  if (guard.overflow) return;
+
   // Boolean schema
   if (node->boolean_schema.has_value()) {
     if (!node->boolean_schema.value()) {
@@ -516,6 +541,7 @@ static void validate_napi(const schema_node_ptr& node,
                             " > maxLength " +
                             std::to_string(node->max_length.value())});
     }
+#ifndef ATA_NO_RE2
     if (node->compiled_pattern) {
       if (!re2::RE2::PartialMatch(sv, *node->compiled_pattern)) {
         errors.push_back({ata::error_code::pattern_mismatch, path,
@@ -523,6 +549,7 @@ static void validate_napi(const schema_node_ptr& node,
                               node->pattern.value()});
       }
     }
+#endif
     if (node->format.has_value()) {
       const auto& fmt = node->format.value();
       bool format_ok = napi_check_format(sv, fmt);
@@ -644,11 +671,13 @@ static void validate_napi(const schema_node_ptr& node,
       }
 
       for (const auto& pp : node->pattern_properties) {
+#ifndef ATA_NO_RE2
         if (pp.compiled && re2::RE2::PartialMatch(key_str, *pp.compiled)) {
           validate_napi(pp.schema, val, env, path + "/" + key_str, ctx,
                         errors);
           matched = true;
         }
+#endif
       }
 
       if (!matched) {
@@ -769,6 +798,67 @@ static void validate_napi(const schema_node_ptr& node,
 // N-API Binding
 // ============================================================================
 
+// ============================================================================
+// simdjson DOM to V8 JS Object conversion
+// ============================================================================
+
+static Napi::Value dom_to_napi(Napi::Env env, simdjson::dom::element el) {
+  using namespace simdjson;
+  switch (el.type()) {
+    case dom::element_type::OBJECT: {
+      auto obj = Napi::Object::New(env);
+      for (auto [key, val] : dom::object(el)) {
+        obj.Set(std::string(key), dom_to_napi(env, val));
+      }
+      return obj;
+    }
+    case dom::element_type::ARRAY: {
+      dom::array arr = el;
+      auto jsArr = Napi::Array::New(env, arr.size());
+      uint32_t i = 0;
+      for (auto val : arr) {
+        jsArr.Set(i++, dom_to_napi(env, val));
+      }
+      return jsArr;
+    }
+    case dom::element_type::STRING: {
+      std::string_view sv;
+      el.get(sv);
+      return Napi::String::New(env, sv.data(), sv.length());
+    }
+    case dom::element_type::INT64: {
+      int64_t v;
+      el.get(v);
+      return Napi::Number::New(env, static_cast<double>(v));
+    }
+    case dom::element_type::UINT64: {
+      uint64_t v;
+      el.get(v);
+      return Napi::Number::New(env, static_cast<double>(v));
+    }
+    case dom::element_type::DOUBLE: {
+      double v;
+      el.get(v);
+      return Napi::Number::New(env, v);
+    }
+    case dom::element_type::BOOL: {
+      bool v;
+      el.get(v);
+      return Napi::Boolean::New(env, v);
+    }
+    case dom::element_type::NULL_VALUE:
+      return env.Null();
+    default:
+      return env.Undefined();
+  }
+}
+
+// Thread-local simdjson DOM parser for parseJSON / validateAndParse
+static simdjson::dom::parser& tl_dom_parser() {
+  thread_local simdjson::dom::parser parser;
+  return parser;
+}
+
 static Napi::Object make_result(Napi::Env env,
                                 const ata::validation_result& result) {
   Napi::Object obj = Napi::Object::New(env);
@@ -794,7 +884,8 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
         {InstanceMethod("validate", &CompiledSchema::Validate),
          InstanceMethod("validateJSON", &CompiledSchema::ValidateJSON),
          InstanceMethod("validateDirect", &CompiledSchema::ValidateDirect),
-         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON)});
+         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON),
+         InstanceMethod("validateAndParse", &CompiledSchema::ValidateAndParse)});
     auto* constructor = new Napi::FunctionReference();
     *constructor = Napi::Persistent(func);
     env.SetInstanceData(constructor);
@@ -916,6 +1007,77 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
     return ValidateDirectImpl(env, info[0]);
   }
 
+  // Parse JSON with simdjson, validate against schema, return parsed JS object
+  Napi::Value ValidateAndParse(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1) {
+      Napi::TypeError::New(env, "JSON string or Buffer expected")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+
+    const char* data;
+    size_t len;
+
+    if (info[0].IsBuffer()) {
+      auto buf = info[0].As<Napi::Buffer<char>>();
+      data = buf.Data();
+      len = buf.Length();
+    } else if (info[0].IsString()) {
+      auto [d, l] = extract_string(env, info[0]);
+      data = d;
+      len = l;
+    } else {
+      Napi::TypeError::New(env, "JSON string or Buffer expected")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+
+    // Parse with simdjson
+    simdjson::padded_string padded(data, len);
+    auto& parser = tl_dom_parser();
+    auto doc_result = parser.parse(padded);
+    if (doc_result.error()) {
+      auto obj = Napi::Object::New(env);
+      obj.Set("valid", false);
+      obj.Set("value", env.Null());
+      auto errors = Napi::Array::New(env, 1);
+      auto err = Napi::Object::New(env);
+      err.Set("code", Napi::Number::New(env, static_cast<int>(ata::error_code::invalid_json)));
+      err.Set("path", Napi::String::New(env, ""));
+      err.Set("message", Napi::String::New(env, "Invalid JSON"));
+      errors[0u] = err;
+      obj.Set("errors", errors);
+      return obj;
+    }
+
+    // Validate
+    auto valResult = ata::validate(schema_, std::string_view(data, len));
+
+    // Convert DOM to JS object
+    Napi::Value jsValue = dom_to_napi(env, doc_result.value());
+
+    // Build result
+    auto obj = Napi::Object::New(env);
+    obj.Set("valid", valResult.valid);
+    obj.Set("value", jsValue);
+    if (valResult.valid) {
+      obj.Set("errors", Napi::Array::New(env, 0));
+    } else {
+      Napi::Array errors = Napi::Array::New(env, valResult.errors.size());
+      for (size_t i = 0; i < valResult.errors.size(); ++i) {
+        Napi::Object err = Napi::Object::New(env);
+        err.Set("code",
+                Napi::Number::New(env, static_cast<int>(valResult.errors[i].code)));
+        err.Set("path", Napi::String::New(env, valResult.errors[i].path));
+        err.Set("message", Napi::String::New(env, valResult.errors[i].message));
+        errors[i] = err;
+      }
+      obj.Set("errors", errors);
+    }
+    return obj;
+  }
+
  private:
   Napi::Value ValidateDirectImpl(Napi::Env env, Napi::Value value) {
     compiled_schema_internal ctx;
@@ -968,6 +1130,44 @@ Napi::Value GetVersion(const Napi::CallbackInfo& info) {
   return Napi::String::New(info.Env(), std::string(ata::version()));
 }
 
+// Standalone JSON parser using simdjson — returns parsed JS object
+Napi::Value ParseJSON(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "JSON string or Buffer expected")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const char* data;
+  size_t len;
+
+  if (info[0].IsBuffer()) {
+    auto buf = info[0].As<Napi::Buffer<char>>();
+    data = buf.Data();
+    len = buf.Length();
+  } else if (info[0].IsString()) {
+    auto [d, l] = CompiledSchema::extract_string(env, info[0]);
+    data = d;
+    len = l;
+  } else {
+    Napi::TypeError::New(env, "JSON string or Buffer expected")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  // Parse with simdjson using thread-local parser
+  simdjson::padded_string padded(data, len);
+  auto& parser = tl_dom_parser();
+  auto result = parser.parse(padded);
+  if (result.error()) {
+    Napi::Error::New(env, "Invalid JSON").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  return dom_to_napi(env, result.value());
+}
+
 // --- Thread Pool ---
 class ThreadPool {
 public:
@@ -1503,6 +1703,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   CompiledSchema::Init(env, exports);
   exports.Set("validate", Napi::Function::New(env, ValidateOneShot));
   exports.Set("version", Napi::Function::New(env, GetVersion));
+  exports.Set("parseJSON", Napi::Function::New(env, ParseJSON));
   exports.Set("fastRegister", Napi::Function::New(env, FastRegister));
   exports.Set("fastValidate", Napi::Function::New(env, FastValidateSlow));
 

package/include/ata.h

@@ -8,14 +8,16 @@
 #include <variant>
 #include <vector>
 
+#define ATA_VERSION "0.9.0"
+
 namespace ata {
 
 inline constexpr uint32_t VERSION_MAJOR = 0;
-inline constexpr uint32_t VERSION_MINOR = 4;
-inline constexpr uint32_t VERSION_REVISION = 3;
+inline constexpr uint32_t VERSION_MINOR = 9;
+inline constexpr uint32_t VERSION_REVISION = 0;
 
 inline constexpr std::string_view version() noexcept {
-  return "0.4.3";
+  return "0.9.0";
 }
 
 enum class error_code : uint8_t {
@@ -64,8 +66,14 @@ struct validation_result {
 
 struct compiled_schema;
 
+struct schema_warning {
+  std::string path;
+  std::string message;
+};
+
 struct schema_ref {
   std::shared_ptr<compiled_schema> impl;
+  std::vector<schema_warning> warnings;
 
   explicit operator bool() const noexcept { return impl != nullptr; }
 };