ata-validator 0.2.0 → 0.4.1

package/index.js

@@ -1,4 +1,60 @@
 const native = require("node-gyp-build")(__dirname);
+const { compileToJS, compileToJSCodegen } = require("./lib/js-compiler");
+
+// 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.
+function buildDefaultsApplier(schema) {
+  if (typeof schema !== 'object' || schema === null) return null;
+  const actions = [];
+  collectDefaults(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+function collectDefaults(schema, actions, path) {
+  if (typeof schema !== 'object' || schema === null) return;
+  const props = schema.properties;
+  if (!props) return;
+  for (const [key, prop] of Object.entries(props)) {
+    if (prop && typeof prop === 'object' && prop.default !== undefined) {
+      const defaultVal = prop.default;
+      if (!path) {
+        actions.push((data) => {
+          if (typeof data === 'object' && data !== null && !(key in data)) {
+            data[key] = typeof defaultVal === 'object' && defaultVal !== null
+              ? JSON.parse(JSON.stringify(defaultVal)) : defaultVal;
+          }
+        });
+      } else {
+        const parentPath = path;
+        actions.push((data) => {
+          let target = data;
+          for (let j = 0; j < parentPath.length; j++) {
+            if (typeof target !== 'object' || target === null) return;
+            target = target[parentPath[j]];
+          }
+          if (typeof target === 'object' && target !== null && !(key in target)) {
+            target[key] = typeof defaultVal === 'object' && defaultVal !== null
+              ? JSON.parse(JSON.stringify(defaultVal)) : defaultVal;
+          }
+        });
+      }
+    }
+    // Recurse into nested object schemas
+    if (prop && typeof prop === 'object' && prop.properties) {
+      collectDefaults(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
+const SIMDJSON_PADDING = 64;
+const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
+
+// Above this size, simdjson On Demand (selective field access) beats JSON.parse
+// (which must materialize the full JS object tree). Buffer.from + NAPI ~2x faster.
+const SIMDJSON_THRESHOLD = 8192;
 
 function parsePointerPath(path) {
   if (!path) return [];
@@ -10,11 +66,90 @@ function parsePointerPath(path) {
     }));
 }
 
+function createPaddedBuffer(jsonStr) {
+  const jsonBuf = Buffer.from(jsonStr);
+  const padded = Buffer.allocUnsafe(jsonBuf.length + SIMDJSON_PADDING);
+  jsonBuf.copy(padded);
+  padded.fill(0, jsonBuf.length);
+  return { buffer: padded, length: jsonBuf.length };
+}
+
 class Validator {
   constructor(schema) {
     const schemaStr =
       typeof schema === "string" ? schema : JSON.stringify(schema);
-    this._compiled = new native.CompiledSchema(schemaStr);
+    const compiled = new native.CompiledSchema(schemaStr);
+    this._compiled = compiled;
+    this._fastSlot = native.fastRegister(schemaStr);
+
+    // Pure JS fast path — no NAPI, runs in V8 JIT
+    // Set ATA_FORCE_NAPI=1 to disable JS codegen (for correctness testing)
+    const schemaObj = typeof schema === "string" ? JSON.parse(schema) : schema;
+    const jsFn = process.env.ATA_FORCE_NAPI
+      ? null
+      : (compileToJSCodegen(schemaObj) || compileToJS(schemaObj));
+    this._jsFn = jsFn;
+
+    // Default value applier — applies schema defaults to objects in-place
+    const applyDefaults = buildDefaultsApplier(schemaObj);
+    this._applyDefaults = applyDefaults;
+
+    // Closure-capture: avoid `this` property lookup on every call.
+    // V8 keeps closure vars in registers — no hidden class traversal.
+    const fastSlot = this._fastSlot;
+
+    // Detect if schema is "selective" — doesn't recurse into arrays/deep objects.
+    // Selective schemas benefit from simdjson On Demand (seeks only needed fields).
+    // Non-selective schemas (items, allOf with nested) touch everything — JSON.parse + jsFn wins.
+    const hasArrayTraversal = schemaObj && (schemaObj.items || schemaObj.prefixItems ||
+      schemaObj.contains || (schemaObj.properties && Object.values(schemaObj.properties).some(
+        p => p && (p.items || p.prefixItems || p.contains))));
+    const useSimdjsonForLarge = !hasArrayTraversal;
+
+    if (jsFn) {
+      this.validate = applyDefaults
+        ? (data) => { applyDefaults(data); return jsFn(data) ? VALID_RESULT : compiled.validate(data); }
+        : (data) => jsFn(data) ? VALID_RESULT : compiled.validate(data);
+      this.isValidObject = jsFn;
+      this.validateJSON = useSimdjsonForLarge
+        ? (jsonStr) => {
+            // Selective schema: large docs use simdjson (skips irrelevant data)
+            if (jsonStr.length >= SIMDJSON_THRESHOLD) {
+              const buf = Buffer.from(jsonStr);
+              if (native.rawFastValidate(fastSlot, buf)) return VALID_RESULT;
+              return compiled.validateJSON(jsonStr);
+            }
+            try {
+              const obj = JSON.parse(jsonStr);
+              if (jsFn(obj)) return VALID_RESULT;
+            } catch (e) {
+              if (!(e instanceof SyntaxError)) throw e;
+            }
+            return compiled.validateJSON(jsonStr);
+          }
+        : (jsonStr) => {
+            // Non-selective schema: JSON.parse + jsFn always wins
+            try {
+              const obj = JSON.parse(jsonStr);
+              if (jsFn(obj)) return VALID_RESULT;
+            } catch (e) {
+              if (!(e instanceof SyntaxError)) throw e;
+            }
+            return compiled.validateJSON(jsonStr);
+          };
+      this.isValidJSON = useSimdjsonForLarge
+        ? (jsonStr) => {
+            if (jsonStr.length >= SIMDJSON_THRESHOLD) {
+              return native.rawFastValidate(fastSlot, Buffer.from(jsonStr));
+            }
+            try { return jsFn(JSON.parse(jsonStr)); }
+            catch (e) { if (!(e instanceof SyntaxError)) throw e; return false; }
+          }
+        : (jsonStr) => {
+            try { return jsFn(JSON.parse(jsonStr)); }
+            catch (e) { if (!(e instanceof SyntaxError)) throw e; return false; }
+          };
+    }
 
     const self = this;
     Object.defineProperty(this, "~standard", {
@@ -22,7 +157,7 @@ class Validator {
         version: 1,
         vendor: "ata-validator",
         validate(value) {
-          const result = self._compiled.validate(value);
+          const result = self.validate(value);
           if (result.valid) {
             return { value };
           }
@@ -40,10 +175,16 @@ class Validator {
     });
   }
 
+  // Fallback methods — only used when JS codegen is unavailable
   validate(data) {
+    if (this._applyDefaults) this._applyDefaults(data);
     return this._compiled.validate(data);
   }
 
+  isValidObject(data) {
+    return this._compiled.validate(data).valid;
+  }
+
   validateJSON(jsonStr) {
     return this._compiled.validateJSON(jsonStr);
   }
@@ -51,6 +192,31 @@ class Validator {
   isValidJSON(jsonStr) {
     return this._compiled.isValidJSON(jsonStr);
   }
+
+  // Raw NAPI fast path for Buffer/Uint8Array
+  isValid(input) {
+    return native.rawFastValidate(this._fastSlot, input);
+  }
+
+  // Zero-copy pre-padded path
+  isValidPrepadded(paddedBuffer, jsonLength) {
+    return native.rawFastValidate(this._fastSlot, paddedBuffer, jsonLength);
+  }
+
+  // Parallel NDJSON batch (multi-core)
+  isValidParallel(buffer) {
+    return native.rawParallelValidate(this._fastSlot, buffer);
+  }
+
+  // Parallel count (fastest — single uint32 return)
+  countValid(buffer) {
+    return native.rawParallelCount(this._fastSlot, buffer);
+  }
+
+  // NDJSON single-thread batch
+  isValidNDJSON(buffer) {
+    return native.rawNDJSONValidate(this._fastSlot, buffer);
+  }
 }
 
 function validate(schema, data) {
@@ -63,4 +229,4 @@ function version() {
   return native.version();
 }
 
-module.exports = { Validator, validate, version };
+module.exports = { Validator, validate, version, createPaddedBuffer, SIMDJSON_PADDING };