ata-validator 0.7.3 → 0.9.0

package/index.js

@@ -264,6 +264,10 @@ function buildPreprocessCodegen(schema, options) {
 // Schema compilation cache: same schema string -> reuse compiled functions
 const _compileCache = new Map();
 
+// Object identity cache: same schema object reference -> reuse entire compiled state
+// Skips JSON.stringify, cache lookup, and all setup. Near-zero cost for repeated schemas.
+const _identityCache = new WeakMap();
+
 const SIMDJSON_PADDING = 64;
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -309,17 +313,31 @@ function buildSchemaMap(schemas) {
   return map
 }
 
+// Resolve a relative URI ref against a base URI
+function resolveRelativeRef(ref, baseId) {
+  if (!baseId || ref.includes('://') || ref.startsWith('#')) return ref
+  const lastSlash = baseId.lastIndexOf('/')
+  if (lastSlash < 0) return ref
+  return baseId.substring(0, lastSlash + 1) + ref
+}
+
 class Validator {
   constructor(schema, opts) {
     const options = opts || {};
     const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
 
+    // Ultra-fast path: same schema object reference -> return cached instance
+    // JS constructor returning an object makes `new` return that object
+    // Cost: one WeakMap lookup. No property copy, no setup, nothing.
+    if (!opts && typeof schema === "object" && schema !== null) {
+      const hit = _identityCache.get(schema);
+      if (hit) return hit;
+    }
+
     // Draft 7 normalization — convert keywords to 2020-12 equivalents in-place
     normalizeDraft7(schemaObj);
 
-    const schemaStr = JSON.stringify(schemaObj);
-
-    this._schemaStr = schemaStr;
+    this._schemaStr = null; // lazy: computed on first use
     this._schemaObj = schemaObj;
     this._options = options;
     this._initialized = false;
@@ -350,6 +368,11 @@ class Validator {
       this._ensureCompiled();
       return this.isValidJSON(jsonStr);
     };
+    this.validateAndParse = (jsonStr) => {
+      if (!native) throw new Error('Native addon required for validateAndParse()');
+      this._ensureCompiled();
+      return this.validateAndParse(jsonStr);
+    };
     this.isValid = (buf) => {
       if (!native) throw new Error('Native addon required for isValid() — use validate() or isValidObject() instead');
       this._ensureCompiled();
@@ -399,23 +422,29 @@ class Validator {
     const schemaObj = this._schemaObj;
     const options = this._options;
 
+    // Lazy stringify — only computed here, not in constructor
+    if (!this._schemaStr) this._schemaStr = JSON.stringify(schemaObj);
+
     // Check cache first -- reuse compiled functions for same schema
     const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
     const mapKey = this._schemaMap.size > 0
       ? this._schemaStr + '\0' + [...this._schemaMap.keys()].sort().join('\0')
       : this._schemaStr;
     const cached = _compileCache.get(mapKey);
-    let jsFn, jsCombinedFn, jsErrFn;
+    let jsFn, jsCombinedFn, jsErrFn, _isCodegen = false;
     var _forceNapi = typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI;
     if (cached && !_forceNapi) {
       jsFn = cached.jsFn;
       jsCombinedFn = cached.combined;
       jsErrFn = cached.errFn;
+      _isCodegen = !!cached.isCodegen;
     } else if (!_forceNapi) {
-      jsFn = compileToJSCodegen(schemaObj, sm) || compileToJS(schemaObj, null, sm);
+      const _cgFn = compileToJSCodegen(schemaObj, sm);
+      jsFn = _cgFn || compileToJS(schemaObj, null, sm);
       jsCombinedFn = compileToJSCombined(schemaObj, VALID_RESULT, sm);
       jsErrFn = compileToJSCodegenWithErrors(schemaObj, sm);
-      _compileCache.set(mapKey, { jsFn, combined: jsCombinedFn, errFn: jsErrFn });
+      _isCodegen = !!_cgFn;
+      _compileCache.set(mapKey, { jsFn, combined: jsCombinedFn, errFn: jsErrFn, isCodegen: _isCodegen });
     } else {
       jsFn = null; jsCombinedFn = null; jsErrFn = null;
     }
@@ -464,15 +493,21 @@ class Validator {
       }
       // errFn: use JS codegen if safe, else lazy-native fallback
       // For unevaluated schemas without errFn, use jsFn as boolean-only fallback
-      const hasUnevaluated = schemaObj && JSON.stringify(schemaObj).includes('unevaluatedProperties') || JSON.stringify(schemaObj).includes('unevaluatedItems')
+      const hasUnevaluated = schemaObj && (schemaObj.unevaluatedProperties !== undefined || schemaObj.unevaluatedItems !== undefined || this._schemaStr.includes('unevaluatedProperties') || this._schemaStr.includes('unevaluatedItems'))
+      const hasDynRef = this._schemaStr.includes('"$dynamicRef"') || this._schemaStr.includes('"$dynamicAnchor"')
       const errFn =
         safeErrFn ||
         (hasUnevaluated
           ? (d) => ({ valid: jsFn(d), errors: jsFn(d) ? [] : [{ code: 'unevaluated', path: '', message: 'unevaluated property or item' }] })
-          : (d) => {
-              this._ensureNative();
-              return this._compiled.validate(d);
-            });
+          : hasDynRef
+            ? (d) => {
+                this._ensureNative();
+                return this._compiled.validateJSON(JSON.stringify(d));
+              }
+            : (d) => {
+                this._ensureNative();
+                return this._compiled.validate(d);
+              });
 
       // Best path: combined validator (single pass, validates + collects errors)
       // Valid data: returns VALID_RESULT, no allocation
@@ -501,23 +536,30 @@ class Validator {
         } catch {}
       }
 
-      if (safeCombinedFn && jsFn) {
-        // Hybrid: jsFn boolean guard for valid (fast, no allocation), combined for invalid
+      if (hasDynRef && _isCodegen && jsFn) {
+        // $dynamicRef with JS codegen: direct path, no wrapper layers
+        const _fn = jsFn, _efn = safeErrFn || errFn, _R = VALID_RESULT;
         this.validate = preprocess
-          ? (data) => {
-              preprocess(data);
-              return jsFn(data) ? VALID_RESULT : safeCombinedFn(data);
-            }
-          : (data) => jsFn(data) ? VALID_RESULT : safeCombinedFn(data);
+          ? (data) => { preprocess(data); return _fn(data) ? _R : _efn(data); }
+          : (data) => _fn(data) ? _R : _efn(data);
+      } else if (hasDynRef) {
+        // $dynamicRef without codegen: delegate to native C++ (interpretive path unreliable)
+        this.validate = preprocess
+          ? (data) => { preprocess(data); return errFn(data); }
+          : errFn;
+      } else if (jsFn && jsFn._hybridFactory) {
+        // Zero-wrapper: hybridFactory bakes VALID_RESULT + errFn into a single function
+        // No arrow function wrapper, no ternary, one function call
+        const hybridFn = jsFn._hybridFactory(VALID_RESULT, safeCombinedFn || errFn);
+        this.validate = preprocess
+          ? (data) => { preprocess(data); return hybridFn(data); }
+          : hybridFn;
       } else if (safeCombinedFn) {
         this.validate = preprocess
-          ? (data) => {
-              preprocess(data);
-              return safeCombinedFn(data);
-            }
+          ? (data) => { preprocess(data); return safeCombinedFn(data); }
           : safeCombinedFn;
       } else {
-        const hybridFn = jsFn._hybridFactory
+        const hybridFn = jsFn && jsFn._hybridFactory
           ? jsFn._hybridFactory(VALID_RESULT, errFn)
           : null;
         this.validate = hybridFn
@@ -592,6 +634,17 @@ class Validator {
               return false;
             }
           };
+      // validateAndParse: requires native addon for simdjson parsing
+      if (native) {
+        const self = this;
+        this.validateAndParse = (jsonStr) => {
+          self._ensureNative();
+          self.validateAndParse = (s) => self._compiled.validateAndParse(s);
+          return self.validateAndParse(jsonStr);
+        };
+      } else {
+        this.validateAndParse = () => { throw new Error('Native addon required for validateAndParse()'); };
+      }
       // 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) {
@@ -616,17 +669,24 @@ class Validator {
         };
       }
     } else if (native) {
-      // ATA_FORCE_NAPI path: no JS codegen, use native for everything
+      // Native-only path: no JS codegen, use native for everything
       this._ensureNative();
+      const _hasDynamic = this._schemaStr.includes('"$dynamicRef"') || this._schemaStr.includes('"$dynamicAnchor"') || this._schemaStr.includes('"$anchor"')
+      // For schemas with dynamic refs/anchors, use validateJSON (C++ path with full support)
+      // instead of validate (NAPI direct V8 path without anchor maps)
+      const _validate = _hasDynamic
+        ? (data) => this._compiled.validateJSON(JSON.stringify(data))
+        : (data) => this._compiled.validate(data);
       this.validate = preprocess
         ? (data) => {
             preprocess(data);
-            return this._compiled.validate(data);
+            return _validate(data);
           }
-        : (data) => this._compiled.validate(data);
-      this.isValidObject = (data) => this._compiled.validate(data).valid;
+        : _validate;
+      this.isValidObject = (data) => _validate(data).valid;
       this.validateJSON = (jsonStr) => this._compiled.validateJSON(jsonStr);
       this.isValidJSON = (jsonStr) => this._compiled.isValidJSON(jsonStr);
+      this.validateAndParse = (jsonStr) => this._compiled.validateAndParse(jsonStr);
       {
         const slot = this._fastSlot;
         this.isValid = (buf) => {
@@ -655,6 +715,11 @@ class Validator {
         };
       }
     }
+
+    // Save to identity cache for ultra-fast reuse with same schema object
+    if (this._schemaObj && typeof this._schemaObj === 'object') {
+      _identityCache.set(this._schemaObj, this);
+    }
   }
 
   _ensureNative() {
@@ -831,6 +896,14 @@ module.exports = { boolFn, hybridFactory, errFn };
       }
     };
 
+    v.validateAndParse = native
+      ? (jsonStr) => {
+          v._ensureNative();
+          v.validateAndParse = (s) => v._compiled.validateAndParse(s);
+          return v.validateAndParse(jsonStr);
+        }
+      : () => { throw new Error('Native addon required for validateAndParse()'); };
+
     // Standard Schema V1
     Object.defineProperty(v, "~standard", {
       value: Object.freeze({
@@ -1030,10 +1103,31 @@ Validator.loadBundle = function (mods, schemas, opts) {
   });
 };
 
+const parseJSON = native ? native.parseJSON : JSON.parse;
+
+// Ultra-fast compile: returns validate function directly, no Validator wrapper
+// WeakMap cached — second call with same schema object is ~3ns
+const _compileFnCache = new WeakMap();
+function compile(schema, opts) {
+  if (!opts && typeof schema === 'object' && schema !== null) {
+    const hit = _compileFnCache.get(schema);
+    if (hit) return hit;
+  }
+  const v = new Validator(schema, opts);
+  v._ensureCompiled();
+  const fn = v.validate;
+  if (!opts && typeof schema === 'object' && schema !== null) {
+    _compileFnCache.set(schema, fn);
+  }
+  return fn;
+}
+
 module.exports = {
   Validator,
+  compile,
   validate,
   version,
   createPaddedBuffer,
   SIMDJSON_PADDING,
+  parseJSON,
 };