ata-validator 0.10.1 → 0.10.2

package/binding/ata_napi.cpp

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "ata.h"
+#include <simdjson.h>
 
 // ============================================================================
 // V8 Direct Object Traversal Engine
@@ -797,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);
@@ -822,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);
@@ -944,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;
@@ -996,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:
@@ -1531,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/lib/js-compiler.js

@@ -6,7 +6,17 @@
 
 // Count Unicode code points, not UTF-16 code units (surrogate pairs).
 // JSON Schema: minLength/maxLength count characters per RFC 8259.
-function _cpLen(s) { let n = 0; for (const _ of s) n++; return n; }
+// Fast path: if no surrogate pairs exist, .length is correct (covers >99% of real data).
+function _cpLen(s) {
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
+      // Found a high surrogate — count code points the slow way
+      let n = 0; for (const _ of s) n++; return n;
+    }
+  }
+  return len;
+}
 
 // AJV-compatible error message templates (compile-time, not runtime)
 const AJV_MESSAGES = {
@@ -275,11 +285,12 @@ function compileToJS(schema, defs, schemaMap) {
   // string
   if (schema.minLength !== undefined) {
     const min = schema.minLength
-    checks.push((d) => typeof d !== 'string' || _cpLen(d) >= min)
+    const min2 = min * 2
+    checks.push((d) => typeof d !== 'string' || d.length >= min2 || (d.length >= min && _cpLen(d) >= min))
   }
   if (schema.maxLength !== undefined) {
     const max = schema.maxLength
-    checks.push((d) => typeof d !== 'string' || _cpLen(d) <= max)
+    checks.push((d) => typeof d !== 'string' || d.length <= max || _cpLen(d) <= max)
   }
   if (schema.pattern) {
     try {

package/lib/schema-parser.js

@@ -0,0 +1,223 @@
+'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 };

package/lib/shape-classifier.js

@@ -24,7 +24,7 @@ const TIER0_PRIMITIVE_ALLOWED = new Set([
   'type', 'enum', 'const',
   'minLength', 'maxLength',
   'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum',
-  'multipleOf', 'format',
+  'multipleOf',
   ...META_KEYS,
 ]);
 

package/lib/tier0.js

@@ -19,10 +19,15 @@ const T_BOOLEAN = TYPE_MASK.boolean;
 
 // Count Unicode code points, not UTF-16 code units.
 // JSON Schema spec: minLength/maxLength count characters (RFC 8259 = code points).
+// Fast path: scan for surrogates first, skip slow iteration for ASCII-only strings.
 function codePointLength(s) {
-  let n = 0;
-  for (const _ of s) n++;
-  return n;
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
+      let n = 0; for (const _ of s) n++; return n;
+    }
+  }
+  return len;
 }
 
 // Numeric constraint flags, packed into constraint.numFlags.
@@ -102,8 +107,8 @@ function checkPrimitive(c, v) {
     if (typeof v !== 'string') return false;
     const minLen = c.minLen;
     const maxLen = c.maxLen;
-    if (minLen >= 0 && codePointLength(v) < minLen) return false;
-    if (maxLen >= 0 && codePointLength(v) > maxLen) return false;
+    if (minLen >= 0) { const l = v.length; if (l < minLen) return false; if (l < minLen * 2 && codePointLength(v) < minLen) return false; }
+    if (maxLen >= 0) { const l = v.length; if (l > maxLen && codePointLength(v) > maxLen) return false; }
   } else if (m === T_INTEGER) {
     if (typeof v !== 'number' || !Number.isInteger(v)) return false;
     const f = c.numFlags;
@@ -156,8 +161,8 @@ function tier0ValidateObject(plan, data) {
       if (typeof v !== 'string') return false;
       const minLen = c.minLen;
       const maxLen = c.maxLen;
-      if (minLen >= 0 && v.length < minLen) return false;
-      if (maxLen >= 0 && v.length > maxLen) return false;
+      if (minLen >= 0) { const l = v.length; if (l < minLen) return false; if (l < minLen * 2 && codePointLength(v) < minLen) return false; }
+      if (maxLen >= 0) { const l = v.length; if (l > maxLen && codePointLength(v) > maxLen) return false; }
     } else if (m === T_INTEGER) {
       if (typeof v !== 'number' || !Number.isInteger(v)) return false;
       const f = c.numFlags;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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",