ata-validator 0.9.3 → 0.10.0

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/index.js

@@ -9,6 +9,8 @@ const {
   compileToJSCombined,
 } = require("./lib/js-compiler");
 const { normalizeDraft7 } = require("./lib/draft7");
+const { classify } = require("./lib/shape-classifier");
+const { buildTier0Plan, tier0Validate } = require("./lib/tier0");
 
 // Extract default values from a schema tree. Returns a function that applies
 // defaults to an object in-place (mutates), or null if no defaults exist.
@@ -413,6 +415,20 @@ class Validator {
       enumerable: false,
       configurable: false,
     });
+
+    // Tier 0 fast path: override isValidObject with a direct bound validator.
+    // All other methods (validate, validateJSON, etc.) stay on the lazy stubs above.
+    // Tier 0/1 are boolean-only; error paths continue through codegen.
+    const _tier = classify(schemaObj);
+    if (_tier.tier === 0) {
+      const _plan = buildTier0Plan(schemaObj);
+      this.isValidObject = (data) => tier0Validate(_plan, data);
+    }
+
+    // Populate identity cache so repeated `new Validator(sameSchema)` short-circuits.
+    if (!opts && typeof schema === "object" && schema !== null) {
+      _identityCache.set(schema, this);
+    }
   }
 
   _ensureCompiled() {

package/lib/shape-classifier.js

@@ -0,0 +1,96 @@
+'use strict';
+
+// Classifies a JSON Schema into one of three execution tiers:
+//   0 - simple object or top-level primitive, fast-path validator
+//   1 - nested objects/arrays, no composition, generic interpreter
+//   2 - composition, $ref, dynamic, etc. -> existing codegen
+//
+// Tier 0/1 validators are BOOLEAN only. Error-returning paths stay on codegen.
+
+const PRIMITIVE_TYPES = new Set(['string', 'number', 'integer', 'boolean']);
+
+// Meta keywords that are always safe to see at any node (annotations, no validation impact)
+const META_KEYS = new Set([
+  '$schema', '$id', '$comment',
+  'title', 'description', 'default', 'examples', 'deprecated', 'readOnly', 'writeOnly',
+]);
+
+const TIER0_OBJECT_ALLOWED = new Set([
+  'type', 'properties', 'required', 'additionalProperties',
+  ...META_KEYS,
+]);
+
+const TIER0_PRIMITIVE_ALLOWED = new Set([
+  'type', 'enum', 'const',
+  'minLength', 'maxLength',
+  'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum',
+  'multipleOf', 'format',
+  ...META_KEYS,
+]);
+
+const MAX_TIER0_PROPS = 10;
+const MAX_TIER0_ENUM = 256;
+
+function isPrimitiveType(t) {
+  return typeof t === 'string' && PRIMITIVE_TYPES.has(t);
+}
+
+function isPrimitiveEnumValue(v) {
+  const t = typeof v;
+  return v === null || t === 'string' || t === 'number' || t === 'boolean';
+}
+
+function isTier0Primitive(schema) {
+  if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) return false;
+  if (!isPrimitiveType(schema.type)) return false;
+  for (const k of Object.keys(schema)) {
+    if (!TIER0_PRIMITIVE_ALLOWED.has(k)) return false;
+  }
+  if (schema.enum !== undefined) {
+    if (!Array.isArray(schema.enum)) return false;
+    if (schema.enum.length === 0 || schema.enum.length > MAX_TIER0_ENUM) return false;
+    for (const v of schema.enum) {
+      if (!isPrimitiveEnumValue(v)) return false;
+    }
+  }
+  if (schema.const !== undefined && !isPrimitiveEnumValue(schema.const)) return false;
+  return true;
+}
+
+function isTier0Object(schema) {
+  if (schema.type !== 'object') return false;
+  for (const k of Object.keys(schema)) {
+    if (!TIER0_OBJECT_ALLOWED.has(k)) return false;
+  }
+  const ap = schema.additionalProperties;
+  if (ap !== undefined && ap !== true && ap !== false) return false;
+  if (schema.required !== undefined) {
+    if (!Array.isArray(schema.required)) return false;
+    for (const r of schema.required) if (typeof r !== 'string') return false;
+  }
+  const props = schema.properties;
+  if (props === undefined) return true;
+  if (typeof props !== 'object' || props === null || Array.isArray(props)) return false;
+  const keys = Object.keys(props);
+  if (keys.length > MAX_TIER0_PROPS) return false;
+  for (const k of keys) {
+    if (!isTier0Primitive(props[k])) return false;
+  }
+  return true;
+}
+
+function classify(schema) {
+  if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+    return { tier: 2, plan: null };
+  }
+  if (isTier0Primitive(schema)) return { tier: 0, plan: null };
+  if (isTier0Object(schema)) return { tier: 0, plan: null };
+  return { tier: 2, plan: null };
+}
+
+module.exports = {
+  classify,
+  MAX_TIER0_PROPS,
+  MAX_TIER0_ENUM,
+  PRIMITIVE_TYPES,
+};

package/lib/tier0.js

@@ -0,0 +1,203 @@
+'use strict';
+
+// Tier 0 fast path: shared parametric validator for simple schemas.
+// All tier-0 Validators call the same tier0Validate() function;
+// the per-instance difference is the plan object.
+// V8 sees one function with monomorphic hidden classes and JIT-compiles it once.
+
+const TYPE_MASK = {
+  string: 1,
+  number: 2,
+  integer: 4,
+  boolean: 8,
+};
+
+const T_STRING = TYPE_MASK.string;
+const T_NUMBER = TYPE_MASK.number;
+const T_INTEGER = TYPE_MASK.integer;
+const T_BOOLEAN = TYPE_MASK.boolean;
+
+// Numeric constraint flags, packed into constraint.numFlags.
+// Using bit flags means the validator does a cheap bitwise-and instead of
+// five Number.isNaN() calls per numeric property when only one bound is set.
+const F_MIN = 1;
+const F_MAX = 2;
+const F_EXCL_MIN = 4;
+const F_EXCL_MAX = 8;
+const F_MULT = 16;
+
+// Build a constraint tuple for one primitive-typed property.
+// All fields have the same layout so every constraint shares one hidden class.
+function primConstraint(key, propSchema) {
+  const t = propSchema.type;
+  const hasEnum = Array.isArray(propSchema.enum);
+  const hasConst = propSchema.const !== undefined;
+  let numFlags = 0;
+  if (typeof propSchema.minimum === 'number') numFlags |= F_MIN;
+  if (typeof propSchema.maximum === 'number') numFlags |= F_MAX;
+  if (typeof propSchema.exclusiveMinimum === 'number') numFlags |= F_EXCL_MIN;
+  if (typeof propSchema.exclusiveMaximum === 'number') numFlags |= F_EXCL_MAX;
+  if (typeof propSchema.multipleOf === 'number') numFlags |= F_MULT;
+  return {
+    key,
+    typeMask: TYPE_MASK[t] | 0,
+    numFlags,
+    hasEnum,
+    hasConst,
+    enumSet: hasEnum ? new Set(propSchema.enum) : null,
+    constVal: hasConst ? propSchema.const : undefined,
+    minLen: typeof propSchema.minLength === 'number' ? propSchema.minLength : -1,
+    maxLen: typeof propSchema.maxLength === 'number' ? propSchema.maxLength : -1,
+    min: typeof propSchema.minimum === 'number' ? propSchema.minimum : 0,
+    max: typeof propSchema.maximum === 'number' ? propSchema.maximum : 0,
+    exclMin: typeof propSchema.exclusiveMinimum === 'number' ? propSchema.exclusiveMinimum : 0,
+    exclMax: typeof propSchema.exclusiveMaximum === 'number' ? propSchema.exclusiveMaximum : 0,
+    multipleOf: typeof propSchema.multipleOf === 'number' ? propSchema.multipleOf : 0,
+  };
+}
+
+function buildTier0Plan(schema) {
+  if (schema.type !== 'object') {
+    return {
+      isPrimitive: true,
+      constraints: [primConstraint('__root__', schema)],
+      requiredMask: 0,
+      additionalAllowed: true,
+      knownKeys: null,
+    };
+  }
+  const props = schema.properties || {};
+  const keys = Object.keys(props);
+  const required = schema.required ? new Set(schema.required) : null;
+  const constraints = new Array(keys.length);
+  const knownKeys = new Set();
+  let requiredMask = 0;
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    constraints[i] = primConstraint(k, props[k]);
+    knownKeys.add(k);
+    if (required && required.has(k)) requiredMask |= (1 << i);
+  }
+  return {
+    isPrimitive: false,
+    constraints,
+    requiredMask,
+    additionalAllowed: schema.additionalProperties !== false,
+    knownKeys,
+  };
+}
+
+// checkPrimitive stays exported for Tier 1 reuse.
+function checkPrimitive(c, v) {
+  const m = c.typeMask;
+  if (m === T_STRING) {
+    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;
+  } else if (m === T_INTEGER) {
+    if (typeof v !== 'number' || !Number.isInteger(v)) return false;
+    const f = c.numFlags;
+    if (f !== 0) {
+      if ((f & F_MIN) && v < c.min) return false;
+      if ((f & F_MAX) && v > c.max) return false;
+      if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+      if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+      if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+    }
+  } else if (m === T_NUMBER) {
+    if (typeof v !== 'number') return false;
+    const f = c.numFlags;
+    if (f !== 0) {
+      if ((f & F_MIN) && v < c.min) return false;
+      if ((f & F_MAX) && v > c.max) return false;
+      if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+      if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+      if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+    }
+  } else if (m === T_BOOLEAN) {
+    if (typeof v !== 'boolean') return false;
+  } else {
+    return false;
+  }
+  if (c.hasEnum && !c.enumSet.has(v)) return false;
+  if (c.hasConst && v !== c.constVal) return false;
+  return true;
+}
+
+// Inlined object validator. Separating the primitive path removes a dead
+// branch from the hot object path.
+function tier0ValidateObject(plan, data) {
+  if (typeof data !== 'object' || data === null || Array.isArray(data)) return false;
+  const cs = plan.constraints;
+  const n = cs.length;
+  const reqMask = plan.requiredMask;
+  let seenMask = 0;
+  for (let i = 0; i < n; i++) {
+    const c = cs[i];
+    const v = data[c.key];
+    if (v === undefined) {
+      if (reqMask & (1 << i)) return false;
+      continue;
+    }
+    seenMask |= (1 << i);
+    // Inlined type + constraint check
+    const m = c.typeMask;
+    if (m === T_STRING) {
+      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;
+    } else if (m === T_INTEGER) {
+      if (typeof v !== 'number' || !Number.isInteger(v)) return false;
+      const f = c.numFlags;
+      if (f !== 0) {
+        if ((f & F_MIN) && v < c.min) return false;
+        if ((f & F_MAX) && v > c.max) return false;
+        if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+        if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+        if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+      }
+    } else if (m === T_NUMBER) {
+      if (typeof v !== 'number') return false;
+      const f = c.numFlags;
+      if (f !== 0) {
+        if ((f & F_MIN) && v < c.min) return false;
+        if ((f & F_MAX) && v > c.max) return false;
+        if ((f & F_EXCL_MIN) && v <= c.exclMin) return false;
+        if ((f & F_EXCL_MAX) && v >= c.exclMax) return false;
+        if ((f & F_MULT) && v % c.multipleOf !== 0) return false;
+      }
+    } else if (m === T_BOOLEAN) {
+      if (typeof v !== 'boolean') return false;
+    } else {
+      return false;
+    }
+    if (c.hasEnum && !c.enumSet.has(v)) return false;
+    if (c.hasConst && v !== c.constVal) return false;
+  }
+  if ((seenMask & reqMask) !== reqMask) return false;
+  if (!plan.additionalAllowed) {
+    const known = plan.knownKeys;
+    for (const k in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, k)) continue;
+      if (!known.has(k)) return false;
+    }
+  }
+  return true;
+}
+
+function tier0Validate(plan, data) {
+  if (plan.isPrimitive) return checkPrimitive(plan.constraints[0], data);
+  return tier0ValidateObject(plan, data);
+}
+
+module.exports = {
+  buildTier0Plan,
+  tier0Validate,
+  tier0ValidateObject,
+  checkPrimitive,
+  TYPE_MASK,
+};

package/package.json

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