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

package/dist/esm/parsers/parseString.js

@@ -1,73 +1,317 @@
-import { withMessage } from "../utils/withMessage.js";
-import { parseSchema } from "./parseSchema.js";
-export const parseString = (schema) => {
-    let r = "z.string()";
-    r += 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 += withMessage(schema, "pattern", ({ json }) => [
-        `.regex(new RegExp(${json})`,
-        ", ",
-        ")",
-    ]);
-    r += withMessage(schema, "minLength", ({ json }) => [
-        `.min(${json}`,
-        ", ",
-        ")",
-    ]);
-    r += withMessage(schema, "maxLength", ({ json }) => [
-        `.max(${json}`,
-        ", ",
-        ")",
-    ]);
-    r += withMessage(schema, "contentEncoding", ({ value }) => {
+"use strict";
+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, 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 = withMessage(schema, "contentMediaType", ({ value }) => {
+    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 += withMessage(schema, "contentSchema", ({ value }) => {
+        r += (0, withMessage_js_1.withMessage)(schema, "contentSchema", ({ value }) => {
             if (value && value instanceof Object) {
-                return [
-                    `.pipe(${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(),
+    };
+}

package/dist/esm/utils/anyOrUnknown.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyOrUnknown = void 0;
 /**
  * Returns "z.unknown()" if the useUnknown option is enabled, otherwise "z.any()".
  * This helper is used throughout the library for fallback cases.
@@ -5,6 +8,7 @@
  * @param refs - The refs object containing options
  * @returns The appropriate Zod schema string
  */
-export const anyOrUnknown = (refs) => {
+const anyOrUnknown = (refs) => {
     return refs?.useUnknown ? "z.unknown()" : "z.any()";
 };
+exports.anyOrUnknown = anyOrUnknown;

package/dist/esm/utils/cliTools.js

@@ -1,5 +1,11 @@
-import { statSync, readFileSync } from "fs";
-export function parseArgs(params, args, help) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.parseOrReadJSON = parseOrReadJSON;
+exports.readPipe = readPipe;
+exports.printParams = printParams;
+const fs_1 = require("fs");
+function parseArgs(params, args, help) {
     const result = {};
     if (help) {
         let index = args.indexOf("--help");
@@ -56,15 +62,15 @@ export function parseArgs(params, args, help) {
     }
     return result;
 }
-export function parseOrReadJSON(jsonOrPath) {
+function parseOrReadJSON(jsonOrPath) {
     jsonOrPath = jsonOrPath.trim();
     if (jsonOrPath.length < 255 &&
-        statSync(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
-        jsonOrPath = readFileSync(jsonOrPath, "utf-8");
+        (0, fs_1.statSync)(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
+        jsonOrPath = (0, fs_1.readFileSync)(jsonOrPath, "utf-8");
     }
     return JSON.parse(jsonOrPath);
 }
-export function readPipe() {
+function readPipe() {
     return new Promise((resolve, reject) => {
         let buf = "";
         process.stdin
@@ -79,7 +85,7 @@ export function readPipe() {
         });
     });
 }
-export function printParams(params) {
+function printParams(params) {
     const longest = Object.keys(params).reduce((l, c) => (c.length > l ? c.length : l), 5);
     const header = "Name " + " ".repeat(longest - 2) + "Short Description";
     console.log(header);

package/dist/esm/utils/cycles.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeScc = exports.detectCycles = exports.findRefDependencies = void 0;
+const findRefDependencies = (schema, validDefNames) => {
+    const deps = new Set();
+    function traverse(obj) {
+        if (obj === null || typeof obj !== "object")
+            return;
+        if (Array.isArray(obj)) {
+            obj.forEach(traverse);
+            return;
+        }
+        const record = obj;
+        if (typeof record["$ref"] === "string") {
+            const ref = record["$ref"];
+            const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+            if (match && validDefNames.includes(match[1])) {
+                deps.add(match[1]);
+            }
+        }
+        for (const value of Object.values(record)) {
+            traverse(value);
+        }
+    }
+    traverse(schema);
+    return deps;
+};
+exports.findRefDependencies = findRefDependencies;
+const detectCycles = (defNames, deps) => {
+    const cycleNodes = new Set();
+    const visited = new Set();
+    const recursionStack = new Set();
+    function dfs(node, path) {
+        if (recursionStack.has(node)) {
+            const cycleStart = path.indexOf(node);
+            for (let i = cycleStart; i < path.length; i++) {
+                cycleNodes.add(path[i]);
+            }
+            cycleNodes.add(node);
+            return;
+        }
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        recursionStack.add(node);
+        const targets = deps.get(node);
+        if (targets) {
+            for (const dep of targets) {
+                dfs(dep, [...path, node]);
+            }
+        }
+        recursionStack.delete(node);
+    }
+    for (const defName of defNames) {
+        if (!visited.has(defName))
+            dfs(defName, []);
+    }
+    return cycleNodes;
+};
+exports.detectCycles = detectCycles;
+const computeScc = (defNames, deps) => {
+    // Tarjan's algorithm, keeps mapping for quick "is this ref in my cycle?"
+    const index = new Map();
+    const lowlink = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const componentByName = new Map();
+    const cycleMembers = new Set();
+    let currentIndex = 0;
+    let componentId = 0;
+    const strongConnect = (v) => {
+        index.set(v, currentIndex);
+        lowlink.set(v, currentIndex);
+        currentIndex += 1;
+        stack.push(v);
+        onStack.add(v);
+        const neighbors = deps.get(v);
+        if (neighbors) {
+            for (const w of neighbors) {
+                if (!index.has(w)) {
+                    strongConnect(w);
+                    lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+                }
+                else if (onStack.has(w)) {
+                    lowlink.set(v, Math.min(lowlink.get(v), index.get(w)));
+                }
+            }
+        }
+        if (lowlink.get(v) === index.get(v)) {
+            const component = [];
+            let w;
+            do {
+                w = stack.pop();
+                if (w === undefined)
+                    break;
+                onStack.delete(w);
+                component.push(w);
+                componentByName.set(w, componentId);
+            } while (w !== v);
+            if (component.length > 1) {
+                component.forEach((name) => cycleMembers.add(name));
+            }
+            componentId += 1;
+        }
+    };
+    for (const name of defNames) {
+        if (!index.has(name)) {
+            strongConnect(name);
+        }
+    }
+    return { cycleMembers, componentByName };
+};
+exports.computeScc = computeScc;

package/dist/esm/utils/half.js

@@ -1,3 +1,7 @@
-export const half = (arr) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.half = void 0;
+const half = (arr) => {
     return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
 };
+exports.half = half;

package/dist/esm/utils/jsdocs.js

@@ -1,4 +1,7 @@
-export const expandJsdocs = (jsdocs) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addJsdocs = exports.expandJsdocs = void 0;
+const expandJsdocs = (jsdocs) => {
     const lines = jsdocs.split("\n");
     const result = lines.length === 1
         ? lines[0]
@@ -6,10 +9,12 @@ export const expandJsdocs = (jsdocs) => {
             .join("\n")}\n`;
     return `/**${result}*/\n`;
 };
-export const addJsdocs = (schema, parsed) => {
+exports.expandJsdocs = expandJsdocs;
+const addJsdocs = (schema, parsed) => {
     const description = schema.description;
     if (!description) {
         return parsed;
     }
-    return `\n${expandJsdocs(description)}${parsed}`;
+    return `\n${(0, exports.expandJsdocs)(description)}${parsed}`;
 };
+exports.addJsdocs = addJsdocs;

package/dist/esm/utils/omit.js

@@ -1,6 +1,10 @@
-export const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omit = void 0;
+const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
     if (!keys.includes(key)) {
         acc[key] = obj[key];
     }
     return acc;
 }, {});
+exports.omit = omit;

package/dist/esm/utils/withMessage.js

@@ -1,17 +1,19 @@
-export function withMessage(schema, key, get) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMessage = withMessage;
+function withMessage(schema, key, get) {
     const value = schema[key];
     let r = "";
     if (value !== undefined) {
         const got = get({ value, json: JSON.stringify(value) });
         if (got) {
-            const opener = got[0];
-            const prefix = got.length === 3 ? got[1] : "";
-            const closer = got.length === 3 ? got[2] : got[1];
+            const { opener, closer, messagePrefix = "", messageCloser } = got;
             r += opener;
             if (schema.errorMessage?.[key] !== undefined) {
-                r += prefix + JSON.stringify(schema.errorMessage[key]);
+                r += messagePrefix + JSON.stringify(schema.errorMessage[key]);
+                r += messageCloser ?? closer;
+                return r;
             }
-            r;
             r += closer;
         }
     }

package/dist/esm/zodToJsonSchema.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Post-processor for Zod's z.toJSONSchema() output.
  *
@@ -14,6 +15,8 @@
  * - patternProperties (stored in __jsonSchema.patternProperties)
  * - if/then/else conditionals (stored in __jsonSchema.conditional)
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconstructJsonSchema = reconstructJsonSchema;
 /**
  * Recursively process a JSON Schema to reconstruct original features from __jsonSchema meta.
  *
@@ -21,7 +24,7 @@
  * - allOf[object, {__jsonSchema: {conditional: ...}}] -> object with if/then/else at top level
  * - patternProperties meta -> patternProperties at current level
  */
-export function reconstructJsonSchema(schema) {
+function reconstructJsonSchema(schema) {
     if (typeof schema !== "object" || schema === null) {
         return schema;
     }

package/dist/types/Types.d.ts

@@ -94,6 +94,11 @@ export type Options = {
      * @default false
      */
     strictOneOf?: boolean;
+    /**
+     * Called when a string format is encountered that has no built-in mapping.
+     * Can be used to log or throw on unknown formats.
+     */
+    onUnknownFormat?: (format: string, path: (string | number)[]) => void;
 };
 export type Refs = Options & {
     path: (string | number)[];
@@ -103,10 +108,13 @@ export type Refs = Options & {
     }>;
     root?: JsonSchema;
     declarations?: Map<string, string>;
+    dependencies?: Map<string, Set<string>>;
     inProgress?: Set<string>;
     refNameByPointer?: Map<string, string>;
     usedNames?: Set<string>;
     currentSchemaName?: string;
+    cycleRefNames?: Set<string>;
+    cycleComponentByName?: Map<string, number>;
 };
 export type SimpleDiscriminatedOneOfSchema<D extends string = string> = JsonSchemaObject & {
     oneOf: (JsonSchemaObject & {