ata-validator 0.11.0 → 0.11.1

package/README.md

@@ -2,7 +2,7 @@
 
 Ultra-fast JSON Schema validator powered by [simdjson](https://github.com/simdjson/simdjson). Multi-core parallel validation, RE2 regex, codegen bytecode engine. Standard Schema V1 compatible.
 
-**[ata-validator.com](https://ata-validator.com)** | **[API Docs](docs/API.md)** | **[Contributing](CONTRIBUTING.md)**
+**[ata-validator.com](https://ata-validator.com)** | **[API Docs](docs/API.md)** | **[Migrate from ajv](docs/migration-from-ajv.md)** | **[Contributing](CONTRIBUTING.md)**
 
 ## Performance
 

package/index.d.ts

@@ -123,3 +123,11 @@ export function createPaddedBuffer(jsonStr: string): { buffer: Buffer; length: n
 
 /** Required padding size for simdjson buffers. */
 export const SIMDJSON_PADDING: number;
+
+/**
+ * Generate a TypeScript declaration (.d.ts source) for the given JSON Schema.
+ * Returns a string containing the generated type plus `isValid` / `validate`
+ * signatures. Used internally by the `ata compile` CLI and exposed for
+ * build-time integrations (Vite plugin, custom build steps).
+ */
+export function toTypeScript(schema: object, options?: { name?: string }): string;

package/index.js

@@ -1216,6 +1216,8 @@ function compile(schema, opts) {
   return fn;
 }
 
+const { toTypeScript } = require("./lib/ts-gen");
+
 module.exports = {
   Validator,
   compile,
@@ -1224,4 +1226,5 @@ module.exports = {
   createPaddedBuffer,
   SIMDJSON_PADDING,
   parseJSON,
+  toTypeScript,
 };

package/lib/js-compiler.js

@@ -675,8 +675,14 @@ function codegenSafe(schema, schemaMap) {
     if (siblings.length > 0 && schema.unevaluatedProperties === undefined && schema.unevaluatedItems === undefined) return false
   }
 
-  // additionalProperties as schema — bail entirely, too many edge cases with allOf interaction
-  if (typeof schema.additionalProperties === 'object') return false
+  // additionalProperties as schema — supported when no composition (allOf/oneOf/anyOf)
+  // is in play, and no patternProperties (unified loop does not emit the
+  // per-key sub-schema walk yet). Closure path handles those cases.
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) {
+    if (schema.allOf || schema.oneOf || schema.anyOf) return false
+    if (schema.patternProperties) return false
+    if (!codegenSafe(schema.additionalProperties, schemaMap)) return false
+  }
   if (schema.additionalProperties === false && !schema.properties) return false
 
   // propertyNames: false — codegen doesn't handle this
@@ -729,6 +735,37 @@ function codegenSafe(schema, schemaMap) {
   return true
 }
 
+// Returns true if the schema (or any nested sub-schema reachable through the
+// usual keywords) has additionalProperties as a schema value. Used by the
+// combined-codegen bail since that path does not emit the per-key loop yet.
+function hasAdditionalPropertiesSchema(schema) {
+  if (typeof schema !== 'object' || schema === null) return false
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null) return true
+  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
+  for (const key of objSubs) {
+    if (schema[key] && typeof schema[key] === 'object') {
+      for (const v of Object.values(schema[key])) {
+        if (hasAdditionalPropertiesSchema(v)) return true
+      }
+    }
+  }
+  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
+  for (const key of arrSubs) {
+    if (Array.isArray(schema[key])) {
+      for (const s of schema[key]) {
+        if (hasAdditionalPropertiesSchema(s)) return true
+      }
+    }
+  }
+  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else', 'propertyNames']
+  for (const key of singleSubs) {
+    if (typeof schema[key] === 'object' && schema[key] !== null) {
+      if (hasAdditionalPropertiesSchema(schema[key])) return true
+    }
+  }
+  return false
+}
+
 // --- Codegen mode: generates a single Function (NOT CSP-safe) ---
 // This matches ajv's approach: one monolithic function, V8 JIT fully inlines it
 function compileToJSCodegen(schema, schemaMap) {
@@ -1274,6 +1311,25 @@ function genCode(schema, v, lines, ctx, knownType) {
         _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
   }
 
+  // additionalProperties as a schema: validate every non-declared property
+  // against that sub-schema. Skip if patternProperties is present (handled by
+  // the unified loop). Composition cases are filtered out by codegenSafe.
+  if (typeof schema.additionalProperties === 'object' && schema.additionalProperties !== null && !schema.patternProperties) {
+    const declared = schema.properties ? Object.keys(schema.properties) : []
+    const skipCheck = declared.length === 0
+      ? null
+      : declared.map(k => `_k===${JSON.stringify(k)}`).join('||')
+    const subLines = []
+    genCode(schema.additionalProperties, '_av', subLines, ctx)
+    if (subLines.length > 0) {
+      const body = subLines.join(';')
+      const loop = skipCheck
+        ? `for(var _k in ${v}){if(${skipCheck})continue;const _av=${v}[_k];${body}}`
+        : `for(var _k in ${v}){const _av=${v}[_k];${body}}`
+      _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
+    }
+  }
+
   // dependentRequired
   if (schema.dependentRequired) {
     for (const [key, deps] of Object.entries(schema.dependentRequired)) {
@@ -2251,6 +2307,9 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
     // Bail on self-referencing schemas — error codegen doesn't support recursion
     if (s.includes('"$ref":"#"')) return null
+    // Bail on additionalProperties as a schema — genCodeE does not emit the
+    // per-key sub-schema loop. Let the closure path handle detailed errors.
+    if (hasAdditionalPropertiesSchema(schema)) return null
   }
   if (typeof schema === 'boolean') {
     return schema
@@ -2752,6 +2811,9 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap) {
     if (s.includes('unevaluatedProperties') || s.includes('unevaluatedItems')) return null
     // Bail on self-referencing schemas — combined codegen doesn't support recursion
     if (s.includes('"$ref":"#"')) return null
+    // Bail on additionalProperties as a schema — combined path doesn't emit the
+    // per-key sub-schema loop yet. The jsFn + errFn fallback handles it correctly.
+    if (hasAdditionalPropertiesSchema(schema)) return null
   }
   if (typeof schema === 'boolean') {
     return schema

package/lib/ts-gen.js

@@ -125,8 +125,11 @@ function toTypeScript(schema, opts) {
   }
 
   const rootType = renderValueType(schema, defs, 0);
-  const isObjectShape = rootType.startsWith('{') || rootType.startsWith('Record<');
-  const rootDecl = isObjectShape && !rootType.includes(' | ')
+  // Use `interface` only for a pure object literal; otherwise fall back to
+  // `type`. Catches cases like `{...}[]` (array of object) and `Record<...>`
+  // which are valid TS but cannot be expressed as an interface body.
+  const isPureObjectLiteral = rootType.startsWith('{') && rootType.endsWith('}') && !rootType.includes(' | ');
+  const rootDecl = isPureObjectLiteral
     ? `export interface ${rootName} ${rootType}`
     : `export type ${rootName} = ${rootType};`;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "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",
@@ -40,6 +40,7 @@
     "test:compat": "node tests/test_compat.js",
     "test:standard-schema": "node tests/test_standard_schema.js",
     "test:browser": "node tests/test_browser.js",
+    "test:ts": "node tests/test_ts_gen.js",
     "bench": "node benchmark/bench_large.js",
     "fuzz": "node tests/fuzz_differential.js",
     "fuzz:long": "FUZZ_ITERATIONS=100000 node tests/fuzz_differential.js",
@@ -60,7 +61,7 @@
     "standard-schema",
     "fastify"
   ],
-  "author": "Mert Can Altin <mertcanaltin01@gmail.com>",
+  "author": "Mert Can Altin <mertgold60@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -103,6 +104,7 @@
     "cmake-js": "^8.0.0",
     "mitata": "^1.0.34",
     "typebox": "^1.1.7",
+    "typescript": "^6.0.3",
     "valibot": "^1.3.1",
     "zod": "^4.3.6"
   },