@gabrielbryk/json-schema-to-zod 2.7.4 → 2.9.0

package/dist/esm/parsers/parseNumber.js

@@ -1,70 +1,112 @@
 import { withMessage } from "../utils/withMessage.js";
 export const parseNumber = (schema) => {
-    let r = "z.number()";
+    const formatError = schema.errorMessage?.format;
+    const numericFormatMap = {
+        int32: "z.int32",
+        uint32: "z.uint32",
+        float32: "z.float32",
+        float64: "z.float64",
+        safeint: "z.safeint",
+        int64: "z.int64",
+        uint64: "z.uint64",
+    };
+    const mappedFormat = schema.format && numericFormatMap[schema.format] ? numericFormatMap[schema.format] : undefined;
+    const formatParams = formatError !== undefined ? `{ error: ${JSON.stringify(formatError)} }` : "";
+    let r = mappedFormat ? `${mappedFormat}(${formatParams})` : "z.number()";
     if (schema.type === "integer") {
-        r += withMessage(schema, "type", () => [".int(", ")"]);
+        if (!mappedFormat) {
+            r += withMessage(schema, "type", () => ({
+                opener: ".int(",
+                closer: ")",
+                messagePrefix: "{ error: ",
+                messageCloser: " })",
+            }));
+        }
     }
     else {
-        r += withMessage(schema, "format", ({ value }) => {
-            if (value === "int64") {
-                return [".int(", ")"];
-            }
-        });
+        if (!mappedFormat) {
+            r += withMessage(schema, "format", ({ value }) => {
+                if (value === "int64") {
+                    return {
+                        opener: ".int(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                }
+            });
+        }
     }
     r += withMessage(schema, "multipleOf", ({ value, json }) => {
         if (value === 1) {
             if (r.startsWith("z.number().int(")) {
                 return;
             }
-            return [".int(", ")"];
+            return {
+                opener: ".int(",
+                closer: ")",
+                messagePrefix: "{ error: ",
+                messageCloser: " })",
+            };
         }
-        return [`.multipleOf(${json}`, ", ", ")"];
+        return {
+            opener: `.multipleOf(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        };
     });
     if (typeof schema.minimum === "number") {
         if (schema.exclusiveMinimum === true) {
-            r += withMessage(schema, "minimum", ({ json }) => [
-                `.gt(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += withMessage(schema, "minimum", ({ json }) => ({
+                opener: `.gt(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
         else {
-            r += withMessage(schema, "minimum", ({ json }) => [
-                `.gte(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += withMessage(schema, "minimum", ({ json }) => ({
+                opener: `.gte(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
     }
     else if (typeof schema.exclusiveMinimum === "number") {
-        r += withMessage(schema, "exclusiveMinimum", ({ json }) => [
-            `.gt(${json}`,
-            ", ",
-            ")",
-        ]);
+        r += withMessage(schema, "exclusiveMinimum", ({ json }) => ({
+            opener: `.gt(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        }));
     }
     if (typeof schema.maximum === "number") {
         if (schema.exclusiveMaximum === true) {
-            r += withMessage(schema, "maximum", ({ json }) => [
-                `.lt(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += withMessage(schema, "maximum", ({ json }) => ({
+                opener: `.lt(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
         else {
-            r += withMessage(schema, "maximum", ({ json }) => [
-                `.lte(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += withMessage(schema, "maximum", ({ json }) => ({
+                opener: `.lte(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
     }
     else if (typeof schema.exclusiveMaximum === "number") {
-        r += withMessage(schema, "exclusiveMaximum", ({ json }) => [
-            `.lt(${json}`,
-            ", ",
-            ")",
-        ]);
+        r += withMessage(schema, "exclusiveMaximum", ({ json }) => ({
+            opener: `.lt(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        }));
     }
     return r;
 };

package/dist/esm/parsers/parseObject.js

@@ -268,6 +268,30 @@ export function parseObject(objectSchema, refs) {
   }`;
             })
                 .join("\n  ")}
+})`;
+        }
+    }
+    // dependentRequired
+    if (objectSchema.dependentRequired && typeof objectSchema.dependentRequired === "object") {
+        const entries = Object.entries(objectSchema.dependentRequired);
+        if (entries.length) {
+            const depRequiredMessage = objectSchema.errorMessage?.dependentRequired ?? "Dependent required properties missing";
+            output += `.superRefine((obj, ctx) => {
+  ${entries
+                .map(([prop, deps]) => {
+                const arr = Array.isArray(deps) ? deps : [];
+                if (!arr.length)
+                    return "";
+                const jsonDeps = JSON.stringify(arr);
+                return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(prop)})) {
+    const missing = ${jsonDeps}.filter((d) => !Object.prototype.hasOwnProperty.call(obj, d));
+    if (missing.length) {
+      ctx.addIssue({ code: "custom", message: ${JSON.stringify(depRequiredMessage)}, path: [], params: { missing } });
+    }
+  }`;
+            })
+                .filter(Boolean)
+                .join("\n  ")}
 })`;
         }
     }

package/dist/esm/parsers/parseSchema.js

@@ -16,17 +16,33 @@ import { parseOneOf } from "./parseOneOf.js";
 import { parseSimpleDiscriminatedOneOf } from "./parseSimpleDiscriminatedOneOf.js";
 import { parseNullable } from "./parseNullable.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { resolveUri } from "../utils/resolveUri.js";
+import { buildRefRegistry } from "../utils/buildRefRegistry.js";
 export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
     // Ensure ref bookkeeping exists so $ref declarations and getter-based recursion work
     refs.root = refs.root ?? schema;
+    refs.rootBaseUri = refs.rootBaseUri ?? "root:///";
     refs.declarations = refs.declarations ?? new Map();
+    refs.dependencies = refs.dependencies ?? new Map();
     refs.inProgress = refs.inProgress ?? new Set();
     refs.refNameByPointer = refs.refNameByPointer ?? new Map();
     refs.usedNames = refs.usedNames ?? new Set();
     if (typeof schema !== "object")
         return schema ? anyOrUnknown(refs) : "z.never()";
+    const parentBase = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
+    const baseUri = typeof schema.$id === "string"
+        ? resolveUri(parentBase, schema.$id)
+        : parentBase;
+    const dynamicAnchors = Array.isArray(refs.dynamicAnchors) ? [...refs.dynamicAnchors] : [];
+    if (typeof schema.$dynamicAnchor === "string") {
+        dynamicAnchors.push({
+            name: schema.$dynamicAnchor,
+            uri: baseUri,
+            path: refs.path,
+        });
+    }
     if (refs.parserOverride) {
-        const custom = refs.parserOverride(schema, refs);
+        const custom = refs.parserOverride(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         if (typeof custom === "string") {
             return custom;
         }
@@ -46,14 +62,14 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
         refs.seen.set(schema, seen);
     }
     if (its.a.ref(schema)) {
-        const parsedRef = parseRef(schema, refs);
+        const parsedRef = parseRef(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         seen.r = parsedRef;
         return parsedRef;
     }
-    let parsed = selectParser(schema, refs);
+    let parsed = selectParser(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
     if (!blockMeta) {
         if (!refs.withoutDescribes) {
-            parsed = addDescribes(schema, parsed, refs);
+            parsed = addDescribes(schema, parsed, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         }
         if (!refs.withoutDefaults) {
             parsed = addDefaults(schema, parsed);
@@ -64,23 +80,47 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
     return parsed;
 };
 const parseRef = (schema, refs) => {
-    const resolved = resolveRef(refs.root, schema.$ref);
+    const refValue = schema.$dynamicRef ?? schema.$ref;
+    const resolved = resolveRef(schema, refValue, refs);
     if (!resolved) {
+        refs.onUnresolvedRef?.(refValue, refs.path);
         return anyOrUnknown(refs);
     }
-    const { schema: target, path } = resolved;
-    const refName = getOrCreateRefName(schema.$ref, path, refs);
+    const { schema: target, path, pointerKey } = resolved;
+    const refName = getOrCreateRefName(pointerKey, path, refs);
     if (!refs.declarations.has(refName) && !refs.inProgress.has(refName)) {
         refs.inProgress.add(refName);
         const declaration = parseSchema(target, {
             ...refs,
             path,
+            currentBaseUri: resolved.baseUri,
             currentSchemaName: refName,
             root: refs.root,
         });
         refs.inProgress.delete(refName);
         refs.declarations.set(refName, declaration);
     }
+    const current = refs.currentSchemaName;
+    if (current) {
+        const deps = refs.dependencies;
+        const set = deps.get(current) ?? new Set();
+        set.add(refName);
+        deps.set(current, set);
+    }
+    const currentComponent = refs.currentSchemaName
+        ? refs.cycleComponentByName?.get(refs.currentSchemaName)
+        : undefined;
+    const targetComponent = refs.cycleComponentByName?.get(refName);
+    const isSameCycle = currentComponent !== undefined &&
+        targetComponent !== undefined &&
+        currentComponent === targetComponent &&
+        refs.cycleRefNames?.has(refName);
+    // Only lazy if the ref stays inside the current strongly-connected component
+    // (or is currently being resolved). This avoids TDZ on true cycles while
+    // letting ordered, acyclic refs stay direct.
+    if (isSameCycle || refs.inProgress.has(refName)) {
+        return `z.lazy(() => ${refName})`;
+    }
     return refName;
 };
 const addDescribes = (schema, parsed, refs) => {
@@ -106,23 +146,93 @@ const addDescribes = (schema, parsed, refs) => {
     }
     return parsed;
 };
-const resolveRef = (root, ref) => {
-    if (!root || !ref.startsWith("#/"))
-        return undefined;
-    const rawSegments = ref
-        .slice(2)
-        .split("/")
-        .filter((segment) => segment.length > 0)
-        .map(decodePointerSegment);
-    let current = root;
-    for (const segment of rawSegments) {
-        if (typeof current !== "object" || current === null)
-            return undefined;
-        current = current[segment];
-    }
-    return { schema: current, path: rawSegments };
+const resolveRef = (schemaNode, ref, refs) => {
+    const base = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
+    // Handle dynamicRef lookup via dynamicAnchors stack
+    const isDynamic = typeof schemaNode.$dynamicRef === "string";
+    if (isDynamic && refs.dynamicAnchors && ref.startsWith("#")) {
+        const name = ref.slice(1);
+        for (let i = refs.dynamicAnchors.length - 1; i >= 0; i -= 1) {
+            const entry = refs.dynamicAnchors[i];
+            if (entry.name === name) {
+                const key = `${entry.uri}#${name}`;
+                const target = refs.refRegistry?.get(key);
+                if (target) {
+                    return { schema: target.schema, path: target.path, baseUri: target.baseUri, pointerKey: key };
+                }
+            }
+        }
+    }
+    // Resolve URI against base
+    const resolvedUri = resolveUri(base, ref);
+    const [uriBase, fragment] = resolvedUri.split("#");
+    const key = fragment ? `${uriBase}#${fragment}` : uriBase;
+    let regEntry = refs.refRegistry?.get(key);
+    if (regEntry) {
+        return { schema: regEntry.schema, path: regEntry.path, baseUri: regEntry.baseUri, pointerKey: key };
+    }
+    // Legacy recursive ref: treat as dynamic to __recursive__
+    if (schemaNode.$recursiveRef) {
+        const recursiveKey = `${base}#__recursive__`;
+        regEntry = refs.refRegistry?.get(recursiveKey);
+        if (regEntry) {
+            return {
+                schema: regEntry.schema,
+                path: regEntry.path,
+                baseUri: regEntry.baseUri,
+                pointerKey: recursiveKey,
+            };
+        }
+    }
+    // External resolver hook
+    const extBase = uriBaseFromRef(resolvedUri);
+    if (refs.resolveExternalRef && extBase && !isLocalBase(extBase, refs.rootBaseUri ?? "")) {
+        const loaded = refs.resolveExternalRef(extBase);
+        if (loaded) {
+            // If async resolver is used synchronously here, it will be ignored; keep simple sync for now
+            const schema = loaded.then ? undefined : loaded;
+            if (schema) {
+                const { registry } = buildRefRegistry(schema, extBase);
+                registry.forEach((entry, k) => refs.refRegistry?.set(k, entry));
+                regEntry = refs.refRegistry?.get(key);
+                if (regEntry) {
+                    return {
+                        schema: regEntry.schema,
+                        path: regEntry.path,
+                        baseUri: regEntry.baseUri,
+                        pointerKey: key,
+                    };
+                }
+            }
+        }
+    }
+    // Backward compatibility: JSON Pointer into root
+    if (refs.root && ref.startsWith("#/")) {
+        const rawSegments = ref
+            .slice(2)
+            .split("/")
+            .filter((segment) => segment.length > 0)
+            .map(decodePointerSegment);
+        let current = refs.root;
+        for (const segment of rawSegments) {
+            if (typeof current !== "object" || current === null)
+                return undefined;
+            current = current[segment];
+        }
+        return { schema: current, path: rawSegments, baseUri: base, pointerKey: ref };
+    }
+    return undefined;
 };
 const decodePointerSegment = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+const uriBaseFromRef = (resolvedUri) => {
+    const hashIdx = resolvedUri.indexOf("#");
+    return hashIdx === -1 ? resolvedUri : resolvedUri.slice(0, hashIdx);
+};
+const isLocalBase = (base, rootBase) => {
+    if (!rootBase)
+        return false;
+    return base === rootBase;
+};
 const getOrCreateRefName = (pointer, path, refs) => {
     if (refs.refNameByPointer?.has(pointer)) {
         return refs.refNameByPointer.get(pointer);
@@ -133,12 +243,24 @@ const getOrCreateRefName = (pointer, path, refs) => {
     return preferred;
 };
 const buildNameFromPath = (path, used) => {
-    const filtered = path.filter((segment) => segment !== "$defs" && segment !== "definitions" && segment !== "properties");
+    const filtered = path
+        .map((segment, idx) => {
+        if (idx === 0 && (segment === "$defs" || segment === "definitions")) {
+            return undefined; // root-level defs prefix is redundant for naming
+        }
+        if (segment === "properties")
+            return undefined; // skip noisy properties segment
+        if (segment === "$defs" || segment === "definitions")
+            return "Defs";
+        return segment;
+    })
+        .filter((segment) => segment !== undefined);
     const base = filtered.length
         ? filtered
             .map((segment) => typeof segment === "number"
             ? `Ref${segment}`
             : segment
+                .toString()
                 .replace(/[^a-zA-Z0-9_$]/g, " ")
                 .split(" ")
                 .filter(Boolean)
@@ -209,7 +331,7 @@ const selectParser = (schema, refs) => {
         return parseMultipleType(schema, refs);
     }
     else if (its.a.primitive(schema, "string")) {
-        return parseString(schema);
+        return parseString(schema, refs);
     }
     else if (its.a.primitive(schema, "number") ||
         its.a.primitive(schema, "integer")) {
@@ -240,7 +362,7 @@ export const its = {
         nullable: (x) => x.nullable === true,
         multipleType: (x) => Array.isArray(x.type),
         not: (x) => x.not !== undefined,
-        ref: (x) => typeof x.$ref === "string",
+        ref: (x) => typeof x.$ref === "string" || typeof x.$dynamicRef === "string",
         const: (x) => x.const !== undefined,
         primitive: (x, p) => x.type === p,
         conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),