ata-validator 0.4.0 → 0.4.2

package/include/ata.h

@@ -12,10 +12,10 @@ namespace ata {
 
 inline constexpr uint32_t VERSION_MAJOR = 0;
 inline constexpr uint32_t VERSION_MINOR = 4;
-inline constexpr uint32_t VERSION_REVISION = 0;
+inline constexpr uint32_t VERSION_REVISION = 1;
 
 inline constexpr std::string_view version() noexcept {
-  return "0.4.0";
+  return "0.4.1";
 }
 
 enum class error_code : uint8_t {

package/index.js

@@ -1,6 +1,179 @@
 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));
+    }
+  }
+}
+
+// Build a function that coerces property values to match schema types in-place.
+// Handles string→number, string→integer, string→boolean, number→string, boolean→string.
+function buildCoercer(schema) {
+  if (typeof schema !== 'object' || schema === null) return null;
+  const actions = [];
+  collectCoercions(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+function collectCoercions(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.type) continue;
+    const targetType = Array.isArray(prop.type) ? null : prop.type;
+    if (!targetType) continue;
+
+    const coerce = buildSingleCoercion(targetType);
+    if (!coerce) continue;
+
+    if (!path) {
+      actions.push((data) => {
+        if (typeof data === 'object' && data !== null && key in data) {
+          const coerced = coerce(data[key]);
+          if (coerced !== undefined) data[key] = coerced;
+        }
+      });
+    } 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) {
+          const coerced = coerce(target[key]);
+          if (coerced !== undefined) target[key] = coerced;
+        }
+      });
+    }
+
+    // Recurse into nested object properties
+    if (prop.properties) {
+      collectCoercions(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
+function buildSingleCoercion(targetType) {
+  switch (targetType) {
+    case 'number': return (v) => {
+      if (typeof v === 'string') { const n = Number(v); if (v !== '' && !isNaN(n)) return n; }
+      if (typeof v === 'boolean') return v ? 1 : 0;
+    };
+    case 'integer': return (v) => {
+      if (typeof v === 'string') { const n = Number(v); if (v !== '' && Number.isInteger(n)) return n; }
+      if (typeof v === 'boolean') return v ? 1 : 0;
+    };
+    case 'string': return (v) => {
+      if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+    };
+    case 'boolean': return (v) => {
+      if (v === 'true' || v === '1') return true;
+      if (v === 'false' || v === '0') return false;
+    };
+    default: return null;
+  }
+}
+
+// Build a function that removes properties not defined in schema.properties.
+// Walks nested objects recursively.
+function buildRemover(schema) {
+  if (typeof schema !== 'object' || schema === null) return null;
+  const actions = [];
+  collectRemovals(schema, actions);
+  if (actions.length === 0) return null;
+  return (data) => {
+    for (let i = 0; i < actions.length; i++) actions[i](data);
+  };
+}
+
+function collectRemovals(schema, actions, path) {
+  if (typeof schema !== 'object' || schema === null || !schema.properties) return;
+
+  // If this level has additionalProperties: false, add a removal action
+  if (schema.additionalProperties === false) {
+    const allowed = new Set(Object.keys(schema.properties));
+    if (!path) {
+      actions.push((data) => {
+        if (typeof data !== 'object' || data === null || Array.isArray(data)) return;
+        const keys = Object.keys(data);
+        for (let i = 0; i < keys.length; i++) {
+          if (!allowed.has(keys[i])) delete data[keys[i]];
+        }
+      });
+    } 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 || Array.isArray(target)) return;
+        const keys = Object.keys(target);
+        for (let i = 0; i < keys.length; i++) {
+          if (!allowed.has(keys[i])) delete target[keys[i]];
+        }
+      });
+    }
+  }
+
+  // Always recurse into nested properties (they may have their own additionalProperties: false)
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    if (prop && typeof prop === 'object' && prop.properties) {
+      collectRemovals(prop, actions, (path || []).concat(key));
+    }
+  }
+}
+
 const SIMDJSON_PADDING = 64;
 const VALID_RESULT = Object.freeze({ valid: true, errors: Object.freeze([]) });
 
@@ -27,7 +200,8 @@ function createPaddedBuffer(jsonStr) {
 }
 
 class Validator {
-  constructor(schema) {
+  constructor(schema, opts) {
+    const options = opts || {};
     const schemaStr =
       typeof schema === "string" ? schema : JSON.stringify(schema);
     const compiled = new native.CompiledSchema(schemaStr);
@@ -42,6 +216,19 @@ class Validator {
       : (compileToJSCodegen(schemaObj) || compileToJS(schemaObj));
     this._jsFn = jsFn;
 
+    // Data mutators — applied in-place before validation
+    const applyDefaults = buildDefaultsApplier(schemaObj);
+    const applyCoerce = options.coerceTypes ? buildCoercer(schemaObj) : null;
+    const applyRemove = options.removeAdditional ? buildRemover(schemaObj) : null;
+    this._applyDefaults = applyDefaults;
+
+    // Combine all mutators into a single pre-validation step
+    const mutators = [applyRemove, applyCoerce, applyDefaults].filter(Boolean);
+    const preprocess = mutators.length === 0 ? null
+      : mutators.length === 1 ? mutators[0]
+      : (data) => { for (let i = 0; i < mutators.length; i++) mutators[i](data); };
+    this._preprocess = preprocess;
+
     // Closure-capture: avoid `this` property lookup on every call.
     // V8 keeps closure vars in registers — no hidden class traversal.
     const fastSlot = this._fastSlot;
@@ -55,7 +242,9 @@ class Validator {
     const useSimdjsonForLarge = !hasArrayTraversal;
 
     if (jsFn) {
-      this.validate = (data) => jsFn(data) ? VALID_RESULT : compiled.validate(data);
+      this.validate = preprocess
+        ? (data) => { preprocess(data); return jsFn(data) ? VALID_RESULT : compiled.validate(data); }
+        : (data) => jsFn(data) ? VALID_RESULT : compiled.validate(data);
       this.isValidObject = jsFn;
       this.validateJSON = useSimdjsonForLarge
         ? (jsonStr) => {
@@ -123,6 +312,7 @@ class Validator {
 
   // Fallback methods — only used when JS codegen is unavailable
   validate(data) {
+    if (this._preprocess) this._preprocess(data);
     return this._compiled.validate(data);
   }
 

package/lib/js-compiler.js

@@ -1,7 +1,7 @@
 'use strict'
 
 // Compile a JSON Schema into a pure JS validator function.
-// No eval, no new Function, CSP-safe.
+// Closure-based validator — no new Function() or eval().
 // Returns null if the schema is too complex for JS compilation.
 
 function compileToJS(schema, defs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Ultra-fast JSON Schema validator. Beats ajv on every valid-path benchmark: 1.1x–2.7x faster validate(obj), 151x faster compilation, 5.9x faster parallel batch. Speculative validation with V8-optimized JS codegen, simdjson, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "types": "index.d.ts",