ata-validator 0.10.2 → 0.10.3

package/binding/ata_napi.cpp

@@ -17,7 +17,6 @@
 #include <vector>
 
 #include "ata.h"
-#include <simdjson.h>
 
 // ============================================================================
 // V8 Direct Object Traversal Engine
@@ -798,67 +797,6 @@ 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);
@@ -884,8 +822,7 @@ class CompiledSchema : public Napi::ObjectWrap<CompiledSchema> {
         {InstanceMethod("validate", &CompiledSchema::Validate),
          InstanceMethod("validateJSON", &CompiledSchema::ValidateJSON),
          InstanceMethod("validateDirect", &CompiledSchema::ValidateDirect),
-         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON),
-         InstanceMethod("validateAndParse", &CompiledSchema::ValidateAndParse)});
+         InstanceMethod("isValidJSON", &CompiledSchema::IsValidJSON)});
     auto* constructor = new Napi::FunctionReference();
     *constructor = Napi::Persistent(func);
     env.SetInstanceData(constructor);
@@ -1007,77 +944,6 @@ 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;
@@ -1130,44 +996,6 @@ 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:
@@ -1703,7 +1531,6 @@ 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,16 +8,16 @@
 #include <variant>
 #include <vector>
 
-#define ATA_VERSION "0.9.0"
+#define ATA_VERSION "0.10.3"
 
 namespace ata {
 
 inline constexpr uint32_t VERSION_MAJOR = 0;
-inline constexpr uint32_t VERSION_MINOR = 9;
-inline constexpr uint32_t VERSION_REVISION = 0;
+inline constexpr uint32_t VERSION_MINOR = 10;
+inline constexpr uint32_t VERSION_REVISION = 3;
 
 inline constexpr std::string_view version() noexcept {
-  return "0.9.0";
+  return "0.10.3";
 }
 
 enum class error_code : uint8_t {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Ultra-fast JSON Schema validator. 4.7x faster validation, 1,800x faster compilation. Works without native addon. Cross-schema $ref, Draft 2020-12 + Draft 7, V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",

package/lib/schema-parser.js

@@ -1,223 +0,0 @@
-'use strict';
-
-// Schema-compiled JSON parser: combines parse + validate in one pass.
-// For known-shape schemas, skips JSON.parse entirely and builds typed
-// JS objects directly from the JSON string.
-//
-// Returns null on invalid JSON or validation failure.
-// Falls back to JSON.parse for unsupported schemas.
-
-function compileSchemaParser(schema) {
-  if (!schema || typeof schema !== 'object') return null;
-
-  // Array of objects
-  if (schema.type === 'array' && schema.items && schema.items.type === 'object') {
-    const itemParser = compileSchemaParser(schema.items);
-    if (!itemParser) return null;
-    return function parseArray(str) {
-      const len = str.length;
-      let pos = 0;
-      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-      if (str.charCodeAt(pos) !== 91) return null; // [
-      pos++;
-      const arr = [];
-      let first = true;
-      while (pos < len) {
-        while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-        if (str.charCodeAt(pos) === 93) return arr; // ]
-        if (!first) {
-          if (str.charCodeAt(pos) !== 44) return null;
-          pos++;
-          while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-        }
-        first = false;
-        // Parse nested object inline
-        const result = parseObject(str, pos, itemParser._keys, itemParser._keyTypes, itemParser._required, itemParser._additionalAllowed);
-        if (result === null) return null;
-        arr.push(result.value);
-        pos = result.pos;
-      }
-      return null;
-    };
-  }
-
-  // Wrapper object containing array
-  if (schema.type === 'object' && schema.properties) {
-    const props = schema.properties;
-    const keys = Object.keys(props);
-    for (const k of keys) {
-      if (props[k] && props[k].type === 'array' && props[k].items) {
-        // Has nested array — use the general parser
-        return compileObjectParser(schema);
-      }
-    }
-    return compileObjectParser(schema);
-  }
-
-  return null;
-}
-
-function compileObjectParser(schema) {
-  if (!schema.properties) return null;
-  const props = schema.properties;
-  const keys = Object.keys(props);
-  const required = new Set(schema.required || []);
-  const additionalAllowed = schema.additionalProperties !== false;
-
-  // Build a key→type map for O(1) lookup
-  const keyTypes = {};
-  for (const k of keys) {
-    const p = props[k];
-    if (!p || typeof p.type !== 'string') return null; // bail on complex
-    if (p.type === 'object' || p.type === 'array') return null; // flat only for now
-    keyTypes[k] = p;
-  }
-
-  // The compiled parser function
-  return function parseAndValidate(str) {
-    const len = str.length;
-    let pos = 0;
-
-    // Skip whitespace
-    while (pos < len && (str.charCodeAt(pos) <= 32)) pos++;
-    if (pos >= len || str.charCodeAt(pos) !== 123) return null; // {
-    pos++;
-
-    const result = {};
-    let foundKeys = 0;
-    let first = true;
-
-    while (pos < len) {
-      // Skip whitespace
-      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-      if (str.charCodeAt(pos) === 125) break; // }
-
-      // Comma between entries
-      if (!first) {
-        if (str.charCodeAt(pos) !== 44) return null; // ,
-        pos++;
-        while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-      }
-      first = false;
-
-      // Key
-      if (str.charCodeAt(pos) !== 34) return null; // "
-      pos++;
-      const keyStart = pos;
-      while (pos < len && str.charCodeAt(pos) !== 34) {
-        if (str.charCodeAt(pos) === 92) pos++; // skip escape
-        pos++;
-      }
-      const key = str.substring(keyStart, pos);
-      pos++; // closing "
-
-      // Colon
-      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-      if (str.charCodeAt(pos) !== 58) return null; // :
-      pos++;
-      while (pos < len && str.charCodeAt(pos) <= 32) pos++;
-
-      // Value — parse based on schema type if known key
-      const propSchema = keyTypes[key];
-      if (propSchema) {
-        const parsed = parseValue(str, pos, propSchema);
-        if (parsed === null) return null; // validation fail
-        result[key] = parsed.value;
-        pos = parsed.pos;
-        foundKeys++;
-      } else if (!additionalAllowed) {
-        return null; // additional property not allowed
-      } else {
-        // Skip unknown value
-        const skipped = skipValue(str, pos);
-        if (skipped < 0) return null;
-        pos = skipped;
-      }
-    }
-
-    // Check required
-    for (const r of required) {
-      if (result[r] === undefined) return null;
-    }
-
-    return result;
-  };
-}
-
-function parseValue(str, pos, schema) {
-  const ch = str.charCodeAt(pos);
-  const type = schema.type;
-
-  if (type === 'string') {
-    if (ch !== 34) return null; // must be "
-    pos++;
-    const start = pos;
-    while (pos < str.length && str.charCodeAt(pos) !== 34) {
-      if (str.charCodeAt(pos) === 92) pos++; // skip escape
-      pos++;
-    }
-    const val = str.substring(start, pos);
-    pos++; // closing "
-    if (schema.minLength !== undefined && val.length < schema.minLength) return null;
-    if (schema.maxLength !== undefined && val.length > schema.maxLength) return null;
-    return { value: val, pos };
-  }
-
-  if (type === 'integer' || type === 'number') {
-    const start = pos;
-    if (str.charCodeAt(pos) === 45) pos++; // -
-    while (pos < str.length && str.charCodeAt(pos) >= 48 && str.charCodeAt(pos) <= 57) pos++;
-    if (type === 'number' && str.charCodeAt(pos) === 46) {
-      pos++;
-      while (pos < str.length && str.charCodeAt(pos) >= 48 && str.charCodeAt(pos) <= 57) pos++;
-    }
-    const val = +str.substring(start, pos);
-    if (type === 'integer' && !Number.isInteger(val)) return null;
-    if (schema.minimum !== undefined && val < schema.minimum) return null;
-    if (schema.maximum !== undefined && val > schema.maximum) return null;
-    return { value: val, pos };
-  }
-
-  if (type === 'boolean') {
-    if (str.startsWith('true', pos)) return { value: true, pos: pos + 4 };
-    if (str.startsWith('false', pos)) return { value: false, pos: pos + 5 };
-    return null;
-  }
-
-  return null;
-}
-
-function skipValue(str, pos) {
-  const ch = str.charCodeAt(pos);
-  if (ch === 34) { // string
-    pos++;
-    while (pos < str.length && str.charCodeAt(pos) !== 34) {
-      if (str.charCodeAt(pos) === 92) pos++;
-      pos++;
-    }
-    return pos + 1;
-  }
-  if (ch === 123 || ch === 91) { // { or [
-    let depth = 1;
-    const open = ch;
-    const close = ch === 123 ? 125 : 93;
-    pos++;
-    while (pos < str.length && depth > 0) {
-      const c = str.charCodeAt(pos);
-      if (c === open) depth++;
-      else if (c === close) depth--;
-      else if (c === 34) { pos++; while (pos < str.length && str.charCodeAt(pos) !== 34) { if (str.charCodeAt(pos) === 92) pos++; pos++; } }
-      pos++;
-    }
-    return pos;
-  }
-  // number, true, false, null
-  while (pos < str.length) {
-    const c = str.charCodeAt(pos);
-    if (c === 44 || c === 125 || c === 93 || c <= 32) break;
-    pos++;
-  }
-  return pos;
-}
-
-module.exports = { compileSchemaParser };