@gabrielbryk/json-schema-to-zod 2.7.3 → 2.8.0

package/dist/cjs/parsers/parseNumber.js

@@ -3,71 +3,113 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseNumber = void 0;
 const withMessage_js_1 = require("../utils/withMessage.js");
 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 += (0, withMessage_js_1.withMessage)(schema, "type", () => [".int(", ")"]);
+        if (!mappedFormat) {
+            r += (0, withMessage_js_1.withMessage)(schema, "type", () => ({
+                opener: ".int(",
+                closer: ")",
+                messagePrefix: "{ error: ",
+                messageCloser: " })",
+            }));
+        }
     }
     else {
-        r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
-            if (value === "int64") {
-                return [".int(", ")"];
-            }
-        });
+        if (!mappedFormat) {
+            r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+                if (value === "int64") {
+                    return {
+                        opener: ".int(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                }
+            });
+        }
     }
     r += (0, withMessage_js_1.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 += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => [
-                `.gt(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+                opener: `.gt(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
         else {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => [
-                `.gte(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+                opener: `.gte(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
     }
     else if (typeof schema.exclusiveMinimum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => [
-            `.gt(${json}`,
-            ", ",
-            ")",
-        ]);
+        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => ({
+            opener: `.gt(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        }));
     }
     if (typeof schema.maximum === "number") {
         if (schema.exclusiveMaximum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => [
-                `.lt(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+                opener: `.lt(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
         else {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => [
-                `.lte(${json}`,
-                ", ",
-                ")",
-            ]);
+            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+                opener: `.lte(${json}`,
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            }));
         }
     }
     else if (typeof schema.exclusiveMaximum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => [
-            `.lt(${json}`,
-            ", ",
-            ")",
-        ]);
+        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => ({
+            opener: `.lt(${json}`,
+            closer: ")",
+            messagePrefix: ", { error: ",
+            messageCloser: " })",
+        }));
     }
     return r;
 };

package/dist/cjs/parsers/parseObject.js

@@ -78,16 +78,16 @@ function parseObject(objectSchema, refs) {
         }
         else {
             if (additionalProperties) {
-                patternProperties += `z.record(z.union([${[
+                patternProperties += `z.record(z.string(), z.union([${[
                     ...Object.values(parsedPatternProperties),
                     additionalProperties,
                 ].join(", ")}]))`;
             }
             else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `z.record(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+                patternProperties += `z.record(z.string(), z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
             }
             else {
-                patternProperties += `z.record(${Object.values(parsedPatternProperties)})`;
+                patternProperties += `z.record(z.string(), ${Object.values(parsedPatternProperties)})`;
             }
         }
         patternProperties += ".superRefine((value, ctx) => {\n";
@@ -103,9 +103,8 @@ function parseObject(objectSchema, refs) {
             }
         }
         for (const key in objectSchema.patternProperties) {
-            const escapedPattern = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
             patternProperties +=
-                "if (key.match(new RegExp(" + JSON.stringify(escapedPattern) + "))) {\n";
+                "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
             if (additionalProperties) {
                 patternProperties += "evaluated = true\n";
             }
@@ -115,7 +114,7 @@ function parseObject(objectSchema, refs) {
                     ".safeParse(value[key])\n";
             patternProperties += "if (!result.success) {\n";
             patternProperties += `ctx.addIssue({
-          path: [...ctx.path, key],
+          path: [...(ctx.path ?? []), key],
           code: 'custom',
           message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
           params: {
@@ -131,7 +130,7 @@ function parseObject(objectSchema, refs) {
                 "const result = " + additionalProperties + ".safeParse(value[key])\n";
             patternProperties += "if (!result.success) {\n";
             patternProperties += `ctx.addIssue({
-          path: [...ctx.path, key],
+          path: [...(ctx.path ?? []), key],
           code: 'custom',
           message: \`Invalid input: must match catchall schema\`,
           params: {
@@ -170,8 +169,8 @@ function parseObject(objectSchema, refs) {
         : patternProperties
             ? patternProperties
             : additionalProperties
-                ? `z.record(${additionalProperties})`
-                : `z.record(${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`;
+                ? `z.record(z.string(), ${additionalProperties})`
+                : `z.record(z.string(), ${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`;
     if (unevaluated === false && properties && !hasCompositionKeywords) {
         output += ".strict()";
     }
@@ -272,6 +271,30 @@ 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/cjs/parsers/parseSchema.js

@@ -23,6 +23,7 @@ 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.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();
@@ -85,6 +86,27 @@ const parseRef = (schema, refs) => {
         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) => {
@@ -213,7 +235,7 @@ const selectParser = (schema, refs) => {
         return (0, parseMultipleType_js_1.parseMultipleType)(schema, refs);
     }
     else if (exports.its.a.primitive(schema, "string")) {
-        return (0, parseString_js_1.parseString)(schema);
+        return (0, parseString_js_1.parseString)(schema, refs);
     }
     else if (exports.its.a.primitive(schema, "number") ||
         exports.its.a.primitive(schema, "integer")) {

package/dist/cjs/parsers/parseString.js

@@ -3,75 +3,315 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseString = void 0;
 const withMessage_js_1 = require("../utils/withMessage.js");
 const parseSchema_js_1 = require("./parseSchema.js");
-const parseString = (schema) => {
-    let r = "z.string()";
-    r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
-        switch (value) {
-            case "email":
-                return [".email(", ")"];
-            case "ip":
-                return [".ip(", ")"];
-            case "ipv4":
-                return ['.ip({ version: "v4"', ", message: ", " })"];
-            case "ipv6":
-                return ['.ip({ version: "v6"', ", message: ", " })"];
-            case "uri":
-                return [".url(", ")"];
-            case "uuid":
-                return [".uuid(", ")"];
-            case "date-time":
-                return [".datetime({ offset: true", ", message: ", " })"];
-            case "time":
-                return [".time(", ")"];
-            case "date":
-                return [".date(", ")"];
-            case "binary":
-                return [".base64(", ")"];
-            case "duration":
-                return [".duration(", ")"];
-        }
-    });
-    r += (0, withMessage_js_1.withMessage)(schema, "pattern", ({ json }) => [
-        `.regex(new RegExp(${json})`,
-        ", ",
-        ")",
-    ]);
-    r += (0, withMessage_js_1.withMessage)(schema, "minLength", ({ json }) => [
-        `.min(${json}`,
-        ", ",
-        ")",
-    ]);
-    r += (0, withMessage_js_1.withMessage)(schema, "maxLength", ({ json }) => [
-        `.max(${json}`,
-        ", ",
-        ")",
-    ]);
+const parseString = (schema, refs) => {
+    const formatError = schema.errorMessage?.format;
+    const refContext = ensureRefs(refs);
+    const topLevelFormatMap = {
+        email: "z.email",
+        ipv4: "z.ipv4",
+        ipv6: "z.ipv6",
+        uri: "z.url",
+        uuid: "z.uuid",
+        cuid: "z.cuid",
+        cuid2: "z.cuid2",
+        nanoid: "z.nanoid",
+        ulid: "z.ulid",
+        jwt: "z.jwt",
+        e164: "z.e164",
+        base64url: "z.base64url",
+        base64: "z.base64",
+        emoji: "z.emoji",
+        "idn-email": "z.email",
+    };
+    const formatFn = schema.format && topLevelFormatMap[schema.format];
+    const formatParam = formatError !== undefined ? `{ error: ${JSON.stringify(formatError)} }` : "";
+    let r = formatFn ? `${formatFn}(${formatParam})` : "z.string()";
+    const formatHandled = Boolean(formatFn);
+    let formatWasHandled = formatHandled;
+    if (!formatHandled) {
+        r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+            switch (value) {
+                case "email":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".email(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "ip":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".ip(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "ipv4":
+                    formatWasHandled = true;
+                    return {
+                        opener: '.ip({ version: "v4"',
+                        closer: " })",
+                        messagePrefix: ", error: ",
+                        messageCloser: " })",
+                    };
+                case "ipv6":
+                    formatWasHandled = true;
+                    return {
+                        opener: '.ip({ version: "v6"',
+                        closer: " })",
+                        messagePrefix: ", error: ",
+                        messageCloser: " })",
+                    };
+                case "uri":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".url(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "uuid":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".uuid(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "cuid":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".cuid(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "cuid2":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".cuid2(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "nanoid":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".nanoid(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "ulid":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".ulid(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "jwt":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".jwt(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "e164":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".e164(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "base64url":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".base64url(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "emoji":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".emoji(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "date-time":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".datetime({ offset: true",
+                        closer: " })",
+                        messagePrefix: ", error: ",
+                        messageCloser: " })",
+                    };
+                case "time":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".time(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "date":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".date(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "binary":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".base64(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "duration":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".duration(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "hostname":
+                case "idn-hostname":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".refine((val) => { if (typeof val !== \"string\" || val.length === 0 || val.length > 253) return false; return val.split(\".\").every((label) => label.length > 0 && label.length <= 63 && /^[A-Za-z0-9-]+$/.test(label) && label[0] !== \"-\" && label[label.length - 1] !== \"-\"); }",
+                        closer: ")",
+                        messagePrefix: ", { error: ",
+                        messageCloser: " })",
+                    };
+                case "idn-email":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".email(",
+                        closer: ")",
+                        messagePrefix: "{ error: ",
+                        messageCloser: " })",
+                    };
+                case "uri-reference":
+                case "iri":
+                case "iri-reference":
+                    formatWasHandled = true;
+                    return {
+                        opener: '.refine((val) => { try { new URL(val, "http://example.com"); return true; } catch { return false; } }',
+                        closer: ")",
+                        messagePrefix: ", { error: ",
+                        messageCloser: " })",
+                    };
+                case "json-pointer":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".refine((val) => typeof val === \"string\" && /^(?:\\/(?:[^/~]|~[01])*)*$/.test(val)",
+                        closer: ")",
+                        messagePrefix: ", { error: ",
+                        messageCloser: " })",
+                    };
+                case "relative-json-pointer":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".refine((val) => typeof val === \"string\" && /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^/~]|~[01])*))*$/.test(val)",
+                        closer: ")",
+                        messagePrefix: ", { error: ",
+                        messageCloser: " })",
+                    };
+                case "uri-template":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".refine((val) => { if (typeof val !== \"string\") return false; const opens = (val.match(/\\{/g) || []).length; const closes = (val.match(/\\}/g) || []).length; return opens === closes; }",
+                        closer: ")",
+                        messagePrefix: ", { error: ",
+                        messageCloser: " })",
+                    };
+                case "regex":
+                    formatWasHandled = true;
+                    return {
+                        opener: ".refine((val) => { try { new RegExp(val); return true; } catch { return false; } }",
+                        closer: ")",
+                        messagePrefix: ", { error: ",
+                        messageCloser: " })",
+                    };
+            }
+        });
+    }
+    if (schema.format && !formatWasHandled) {
+        refContext.onUnknownFormat?.(schema.format, refContext.path);
+    }
+    r += (0, withMessage_js_1.withMessage)(schema, "pattern", ({ json }) => ({
+        opener: `.regex(new RegExp(${json})`,
+        closer: ")",
+        messagePrefix: ", { error: ",
+        messageCloser: " })",
+    }));
+    r += (0, withMessage_js_1.withMessage)(schema, "minLength", ({ json }) => ({
+        opener: `.min(${json}`,
+        closer: ")",
+        messagePrefix: ", { error: ",
+        messageCloser: " })",
+    }));
+    r += (0, withMessage_js_1.withMessage)(schema, "maxLength", ({ json }) => ({
+        opener: `.max(${json}`,
+        closer: ")",
+        messagePrefix: ", { error: ",
+        messageCloser: " })",
+    }));
     r += (0, withMessage_js_1.withMessage)(schema, "contentEncoding", ({ value }) => {
         if (value === "base64") {
-            return [".base64(", ")"];
+            return {
+                opener: ".base64(",
+                closer: ")",
+                messagePrefix: "{ error: ",
+                messageCloser: " })",
+            };
         }
     });
     const contentMediaType = (0, withMessage_js_1.withMessage)(schema, "contentMediaType", ({ value }) => {
         if (value === "application/json") {
-            return [
-                ".transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: \"custom\", message: \"Invalid JSON\" }); }}",
-                ", ",
-                ")"
-            ];
+            return {
+                opener: '.transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: "custom", message: "Invalid JSON" }); }}',
+                closer: ")",
+                messagePrefix: ", { error: ",
+                messageCloser: " })",
+            };
         }
     });
     if (contentMediaType != "") {
         r += contentMediaType;
         r += (0, withMessage_js_1.withMessage)(schema, "contentSchema", ({ value }) => {
             if (value && value instanceof Object) {
-                return [
-                    `.pipe(${(0, parseSchema_js_1.parseSchema)(value)}`,
-                    ", ",
-                    ")"
-                ];
+                return {
+                    opener: `.pipe(${(0, parseSchema_js_1.parseSchema)(value, refContext)}`,
+                    closer: ")",
+                    messagePrefix: ", { error: ",
+                    messageCloser: " })",
+                };
             }
         });
     }
     return r;
 };
 exports.parseString = parseString;
+function ensureRefs(refs) {
+    if (refs)
+        return refs;
+    return {
+        path: [],
+        seen: new Map(),
+        declarations: new Map(),
+        dependencies: new Map(),
+        inProgress: new Set(),
+        refNameByPointer: new Map(),
+        usedNames: new Set(),
+    };
+}