ata-validator 0.12.3 → 0.12.5

package/index.d.ts

@@ -4,8 +4,17 @@ export interface ValidationError {
   schemaPath: string;
   params: Record<string, unknown>;
   message: string;
+  /**
+   * The schema object that owns the failing keyword. Populated only when the
+   * Validator was constructed with `verbose: true`. Matches ajv's `verbose`
+   * behavior.
+   */
+  parentSchema?: object;
 }
 
+/** A user-supplied format checker. Receives the candidate value, returns true if valid. */
+export type FormatChecker = (value: string) => boolean;
+
 export interface ValidationResult {
   valid: boolean;
   errors: ValidationError[];
@@ -21,6 +30,26 @@ export interface ValidatorOptions {
   coerceTypes?: boolean;
   removeAdditional?: boolean;
   schemas?: Record<string, object> | object[];
+  /**
+   * Custom format checkers. Keys are format names referenced from `format` in
+   * the schema. Values are functions that return true when the input is valid.
+   */
+  formats?: Record<string, FormatChecker>;
+  /**
+   * When true, validation errors include `parentSchema` (the schema object
+   * that produced the error). Matches ajv's `verbose: true`.
+   */
+  verbose?: boolean;
+  /**
+   * When true, validate() returns a shared frozen result on the first failure
+   * instead of collecting full error details. Smaller hot-path allocation.
+   */
+  abortEarly?: boolean;
+}
+
+export interface BundleStandaloneOptions extends ValidatorOptions {
+  /** Module format for the emitted bundle. Default: 'cjs'. */
+  format?: 'esm' | 'cjs';
 }
 
 export interface StandardSchemaV1Props {
@@ -30,7 +59,13 @@ export interface StandardSchemaV1Props {
     value: unknown
   ):
     | { value: unknown }
-    | { issues: Array<{ message: string; path?: ReadonlyArray<{ key: PropertyKey }> }> };
+    | {
+        issues: Array<{
+          message: string;
+          /** Array indices are emitted as numbers, object keys as strings. */
+          path?: ReadonlyArray<{ key: PropertyKey }>;
+        }>;
+      };
 }
 
 export interface StandaloneModule {
@@ -98,8 +133,12 @@ export class Validator {
   /** Bundle multiple schemas into a single JS module string. Load with Validator.loadBundle(). */
   static bundle(schemas: object[], options?: ValidatorOptions): string;
 
-  /** Bundle multiple schemas into a self-contained JS module. No ata-validator import needed at runtime. */
-  static bundleStandalone(schemas: object[], options?: ValidatorOptions): string;
+  /**
+   * Bundle multiple schemas into a self-contained JS module with no
+   * ata-validator runtime dependency. Cross-schema `$ref` resolves between
+   * the supplied schemas. Set `format: 'esm'` for ESM output (default 'cjs').
+   */
+  static bundleStandalone(schemas: object[], options?: BundleStandaloneOptions): string;
 
   /** Bundle multiple schemas with deduplicated shared templates. Smaller output than bundle(). */
   static bundleCompact(schemas: object[], options?: ValidatorOptions): string;

package/lib/js-compiler.js

@@ -496,6 +496,50 @@ function collectDefs(schema) {
   return defs
 }
 
+// Walk a JSON-pointer fragment ("/foo/bar/0") into a schema object.
+// Returns the target node, or null if any segment is missing.
+function walkJsonPointer(root, fragment) {
+  if (!fragment || fragment === '/' || fragment === '#') return root
+  const path = fragment.startsWith('#') ? fragment.slice(1) : fragment
+  if (!path.startsWith('/')) return null
+  const parts = path.split('/').slice(1).map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'))
+  let target = root
+  for (const p of parts) {
+    if (target == null || typeof target !== 'object') return null
+    target = target[p]
+  }
+  return target == null ? null : target
+}
+
+// Resolve a cross-schema $ref of the form "<id>#/<json-pointer>" (or just "<id>").
+// Returns { schema, fullId } where fullId is the resolved $id of the host schema.
+function resolveCrossSchemaRef(ref, schemaMap) {
+  if (!schemaMap) return null
+  const hashIdx = ref.indexOf('#')
+  const baseId = hashIdx >= 0 ? ref.slice(0, hashIdx) : ref
+  const fragment = hashIdx >= 0 ? ref.slice(hashIdx) : ''
+  if (!baseId) return null
+
+  let baseSchema = null
+  let fullId = null
+  if (schemaMap.has(baseId)) {
+    baseSchema = schemaMap.get(baseId)
+    fullId = baseId
+  } else if (!ref.includes('://')) {
+    for (const [id] of schemaMap) {
+      if (id.endsWith('/' + baseId)) {
+        baseSchema = schemaMap.get(id)
+        fullId = id
+        break
+      }
+    }
+  }
+  if (!baseSchema) return null
+  const target = fragment ? walkJsonPointer(baseSchema, fragment) : baseSchema
+  if (target == null) return null
+  return { schema: target, fullId }
+}
+
 function resolveRef(ref, defs, schemaMap) {
   // Self-reference: "#" — treat as permissive to avoid infinite recursion
   if (ref === '#') return () => true
@@ -520,7 +564,15 @@ function resolveRef(ref, defs, schemaMap) {
     const fn = compileToJS(resolved, null, schemaMap)
     return fn || (() => true)
   }
-  // 3. Cross-schema ref (relative URI resolution)
+  // 3. Cross-schema ref with JSON pointer fragment ("<id>#/<path>")
+  if (schemaMap && ref.includes('#')) {
+    const r = resolveCrossSchemaRef(ref, schemaMap)
+    if (r) {
+      const fn = compileToJS(r.schema, null, schemaMap)
+      return fn || (() => true)
+    }
+  }
+  // 4. Cross-schema ref (relative URI resolution, no fragment)
   if (schemaMap && !ref.includes('://') && !ref.startsWith('#')) {
     for (const [id] of schemaMap) {
       if (id.endsWith('/' + ref)) {
@@ -652,6 +704,11 @@ function codegenSafe(schema, schemaMap) {
         if (id.endsWith('/' + schema.$ref)) { isResolvable = true; resolvedTarget = schemaMap.get(id); break }
       }
     }
+    // Cross-schema ref with JSON pointer fragment: "<id>#/<path>"
+    if (!isLocal && !isResolvable && schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, schemaMap)
+      if (r) { isResolvable = true; resolvedTarget = r.schema }
+    }
     // Anchor-style ref: #name (not #/path, not bare #) — resolvable at compile time via anchors map
     const isAnchorRef = !isLocal && !isResolvable && schema.$ref.length > 1 && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')
     if (!isLocal && !isResolvable && !isAnchorRef) return false
@@ -1093,13 +1150,17 @@ function genCode(schema, v, lines, ctx, knownType) {
         }
       }
     } else if (schema.$ref !== '#' && ctx.schemaMap) {
-      // 2. Cross-schema ref (exact match or relative URI)
+      // 2. Cross-schema ref (exact match, relative URI, or JSON pointer fragment)
       let resolved = ctx.schemaMap.get(schema.$ref)
       if (!resolved && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
         for (const [id, s] of ctx.schemaMap) {
           if (id.endsWith('/' + schema.$ref)) { resolved = s; break }
         }
       }
+      if (!resolved && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+        const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+        if (r) resolved = r.schema
+      }
       if (resolved) {
         if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
         else {
@@ -2516,6 +2577,17 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ctx.refStack.delete(schema.$ref)
       return
     }
+    // Cross-schema ref with JSON pointer fragment ("<id>#/<path>")
+    if (ctx.schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+      if (r) {
+        if (ctx.refStack.has(schema.$ref)) return
+        ctx.refStack.add(schema.$ref)
+        genCodeE(r.schema, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(schema.$ref)
+        return
+      }
+    }
   }
 
   // $dynamicRef — resolve via anchors map
@@ -3022,6 +3094,17 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ctx.refStack.delete(schema.$ref)
       return
     }
+    // Cross-schema ref with JSON pointer fragment ("<id>#/<path>")
+    if (ctx.schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+      if (r) {
+        if (ctx.refStack.has(schema.$ref)) return
+        ctx.refStack.add(schema.$ref)
+        genCodeC(r.schema, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(schema.$ref)
+        return
+      }
+    }
   }
 
   // $dynamicRef — resolve via anchors map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "description": "Ultra-fast JSON Schema validator. 5x faster validation, 159,000x 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",