@gabrielbryk/json-schema-to-zod 2.7.2

package/dist/esm/parsers/parseString.js

@@ -0,0 +1,73 @@
+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 }) => {
+        if (value === "base64") {
+            return [".base64(", ")"];
+        }
+    });
+    const contentMediaType = 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\" }); }}",
+                ", ",
+                ")"
+            ];
+        }
+    });
+    if (contentMediaType != "") {
+        r += contentMediaType;
+        r += withMessage(schema, "contentSchema", ({ value }) => {
+            if (value && value instanceof Object) {
+                return [
+                    `.pipe(${parseSchema(value)}`,
+                    ", ",
+                    ")"
+                ];
+            }
+        });
+    }
+    return r;
+};

package/dist/esm/utils/anyOrUnknown.js

@@ -0,0 +1,10 @@
+/**
+ * Returns "z.unknown()" if the useUnknown option is enabled, otherwise "z.any()".
+ * This helper is used throughout the library for fallback cases.
+ *
+ * @param refs - The refs object containing options
+ * @returns The appropriate Zod schema string
+ */
+export const anyOrUnknown = (refs) => {
+    return refs?.useUnknown ? "z.unknown()" : "z.any()";
+};

package/dist/esm/utils/cliTools.js

@@ -0,0 +1,102 @@
+import { statSync, readFileSync } from "fs";
+export function parseArgs(params, args, help) {
+    const result = {};
+    if (help) {
+        let index = args.indexOf("--help");
+        if (index === -1) {
+            index = args.indexOf("-h");
+        }
+        if (index !== -1) {
+            printParams({
+                ...params,
+                help: {
+                    shorthand: "h",
+                    description: typeof help === "string" ? help : "Display this message :)",
+                },
+            });
+            process.exit(0);
+        }
+    }
+    for (const name in params) {
+        const { shorthand, required, value } = params[name];
+        let index = args.indexOf("--" + name);
+        if (index === -1 && shorthand) {
+            index = args.indexOf("-" + shorthand);
+        }
+        if (index === -1) {
+            if (required || required === "") {
+                throw new Error(typeof required === "string" && required !== ""
+                    ? required
+                    : `Missing required argument ${name}`);
+            }
+            result[name] = false;
+            continue;
+        }
+        if (value) {
+            const val = args[index + 1];
+            if (val === undefined) {
+                throw new Error(`Expected a value for argument ${name}`);
+            }
+            if (value === "number") {
+                const asNumber = Number(val);
+                if (isNaN(asNumber)) {
+                    throw new Error(`Value of argument ${name} must be a valid number`);
+                }
+                result[name] = asNumber;
+                continue;
+            }
+            if (Array.isArray(value) && !value.includes(val)) {
+                throw new Error(`Value of argument ${name} must be one of ${value}`);
+            }
+            result[name] = val;
+        }
+        else {
+            result[name] = true;
+        }
+    }
+    return result;
+}
+export function parseOrReadJSON(jsonOrPath) {
+    jsonOrPath = jsonOrPath.trim();
+    if (jsonOrPath.length < 255 &&
+        statSync(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
+        jsonOrPath = readFileSync(jsonOrPath, "utf-8");
+    }
+    return JSON.parse(jsonOrPath);
+}
+export function readPipe() {
+    return new Promise((resolve, reject) => {
+        let buf = "";
+        process.stdin
+            .setEncoding("utf-8")
+            .on("end", () => resolve(buf))
+            .on("error", reject)
+            .on("readable", () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) != null) {
+                buf += chunk;
+            }
+        });
+    });
+}
+export 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);
+    for (const name in params) {
+        let { shorthand, description } = params[name];
+        if (shorthand) {
+            shorthand = " -" + shorthand;
+        }
+        else {
+            shorthand = "   ";
+        }
+        if (description) {
+            description = "    " + description;
+        }
+        else {
+            description = "";
+        }
+        console.log("--" + name + " ".repeat(longest - name.length) + shorthand + description);
+    }
+}

package/dist/esm/utils/half.js

@@ -0,0 +1,3 @@
+export const half = (arr) => {
+    return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
+};

package/dist/esm/utils/jsdocs.js

@@ -0,0 +1,15 @@
+export const expandJsdocs = (jsdocs) => {
+    const lines = jsdocs.split("\n");
+    const result = lines.length === 1
+        ? lines[0]
+        : `\n${lines.map(x => `* ${x}`)
+            .join("\n")}\n`;
+    return `/**${result}*/\n`;
+};
+export const addJsdocs = (schema, parsed) => {
+    const description = schema.description;
+    if (!description) {
+        return parsed;
+    }
+    return `\n${expandJsdocs(description)}${parsed}`;
+};

package/dist/esm/utils/omit.js

@@ -0,0 +1,6 @@
+export const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
+    if (!keys.includes(key)) {
+        acc[key] = obj[key];
+    }
+    return acc;
+}, {});

package/dist/esm/utils/withMessage.js

@@ -0,0 +1,19 @@
+export 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];
+            r += opener;
+            if (schema.errorMessage?.[key] !== undefined) {
+                r += prefix + JSON.stringify(schema.errorMessage[key]);
+            }
+            r;
+            r += closer;
+        }
+    }
+    return r;
+}

package/dist/esm/zodToJsonSchema.js

@@ -0,0 +1,86 @@
+/**
+ * Post-processor for Zod's z.toJSONSchema() output.
+ *
+ * When `preserveJsonSchemaForRoundTrip` was used during JSON Schema → Zod conversion,
+ * this function reconstructs the original JSON Schema features from the stored __jsonSchema meta.
+ *
+ * Usage:
+ * 1. Convert JSON Schema to Zod code with `preserveJsonSchemaForRoundTrip: true`
+ * 2. Evaluate the Zod code to get a schema instance
+ * 3. Call Zod's `z.toJSONSchema(schema)` to get JSON Schema output
+ * 4. Pass that output to `reconstructJsonSchema()` to restore preserved features
+ *
+ * Handles:
+ * - patternProperties (stored in __jsonSchema.patternProperties)
+ * - if/then/else conditionals (stored in __jsonSchema.conditional)
+ */
+/**
+ * Recursively process a JSON Schema to reconstruct original features from __jsonSchema meta.
+ *
+ * Handles special cases:
+ * - allOf[object, {__jsonSchema: {conditional: ...}}] -> object with if/then/else at top level
+ * - patternProperties meta -> patternProperties at current level
+ */
+export function reconstructJsonSchema(schema) {
+    if (typeof schema !== "object" || schema === null) {
+        return schema;
+    }
+    const result = { ...schema };
+    // Handle allOf structures created by .and() with conditionals
+    // Pattern: allOf: [mainSchema, {__jsonSchema: {conditional: ...}, anyOf: [...]}]
+    if (Array.isArray(result.allOf) &&
+        result.allOf.length === 2 &&
+        typeof result.allOf[1] === "object" &&
+        result.allOf[1] !== null) {
+        const secondElement = result.allOf[1];
+        // Check if second element has conditional meta
+        if (secondElement.__jsonSchema &&
+            typeof secondElement.__jsonSchema === "object" &&
+            secondElement.__jsonSchema.conditional) {
+            // Extract the main schema and conditional
+            const mainSchema = reconstructJsonSchema(result.allOf[0]);
+            const conditionalMeta = secondElement.__jsonSchema
+                .conditional;
+            // Merge: main schema + if/then/else at top level
+            const merged = {
+                ...mainSchema,
+                if: conditionalMeta.if,
+                then: conditionalMeta.then,
+                else: conditionalMeta.else,
+            };
+            // Recursively process the merged result
+            return reconstructJsonSchema(merged);
+        }
+    }
+    // Check for __jsonSchema meta at this level
+    if (result.__jsonSchema && typeof result.__jsonSchema === "object") {
+        const preserved = result.__jsonSchema;
+        // Reconstruct patternProperties
+        if (preserved.patternProperties) {
+            result.patternProperties = preserved.patternProperties;
+        }
+        // Reconstruct if/then/else conditional (for non-allOf cases)
+        if (preserved.conditional) {
+            const conditional = preserved.conditional;
+            result.if = conditional.if;
+            result.then = conditional.then;
+            result.else = conditional.else;
+        }
+        // Remove the __jsonSchema meta from the output
+        delete result.__jsonSchema;
+    }
+    // Recursively process nested schemas
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            if (Array.isArray(value)) {
+                result[key] = value.map((item) => typeof item === "object" && item !== null
+                    ? reconstructJsonSchema(item)
+                    : item);
+            }
+            else {
+                result[key] = reconstructJsonSchema(value);
+            }
+        }
+    }
+    return result;
+}

package/dist/types/Types.d.ts

@@ -0,0 +1,125 @@
+export type Serializable = {
+    [key: string]: Serializable;
+} | Serializable[] | string | number | boolean | null;
+export type JsonSchema = JsonSchemaObject | boolean;
+export type JsonSchemaObject = {
+    type?: string | string[];
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    definitions?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    examples?: Serializable[];
+    deprecated?: boolean;
+    dependentSchemas?: Record<string, JsonSchema>;
+    contains?: JsonSchema;
+    minContains?: number;
+    maxContains?: number;
+    properties?: {
+        [key: string]: JsonSchema;
+    };
+    additionalProperties?: JsonSchema;
+    unevaluatedProperties?: boolean | JsonSchema;
+    patternProperties?: {
+        [key: string]: JsonSchema;
+    };
+    minProperties?: number;
+    maxProperties?: number;
+    required?: string[] | boolean;
+    propertyNames?: JsonSchema;
+    items?: JsonSchema | JsonSchema[];
+    additionalItems?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
+    multipleOf?: number;
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    if?: JsonSchema;
+    then?: JsonSchema;
+    else?: JsonSchema;
+    const?: Serializable;
+    enum?: Serializable[];
+    errorMessage?: {
+        [key: string]: string | undefined;
+    };
+} & {
+    [key: string]: any;
+};
+export type ParserSelector = (schema: JsonSchemaObject, refs: Refs) => string;
+export type ParserOverride = (schema: JsonSchemaObject, refs: Refs) => string | void;
+export type Options = {
+    name?: string;
+    module?: "cjs" | "esm" | "none";
+    withoutDefaults?: boolean;
+    withoutDescribes?: boolean;
+    withJsdocs?: boolean;
+    /** Use .meta() instead of .describe() - includes id, title, description */
+    withMeta?: boolean;
+    parserOverride?: ParserOverride;
+    depth?: number;
+    type?: boolean | string;
+    noImport?: boolean;
+    /** Export all generated reference schemas (for $refs) when using ESM */
+    exportRefs?: boolean;
+    /**
+     * Store original JSON Schema constructs in .meta({ __jsonSchema: {...} })
+     * for features that can't be natively represented in Zod (patternProperties,
+     * if/then/else, etc.). This enables round-trip conversion back to JSON Schema.
+     */
+    preserveJsonSchemaForRoundTrip?: boolean;
+    /**
+     * Use z.unknown() instead of z.any() for fallback cases.
+     * This provides better type safety as z.unknown() requires type checking
+     * before using the value, while z.any() bypasses TypeScript checks entirely.
+     * @default false
+     */
+    useUnknown?: boolean;
+    /**
+     * Enforce strict oneOf semantics where exactly one schema must match.
+     * When false (default), oneOf behaves like "at least one must match" (same as Zod union).
+     * When true, adds superRefine to enforce "exactly one must match".
+     *
+     * Note: Strict enforcement often fails with schemas that have overlapping base types.
+     * @default false
+     */
+    strictOneOf?: boolean;
+};
+export type Refs = Options & {
+    path: (string | number)[];
+    seen: Map<object | boolean, {
+        n: number;
+        r: string | undefined;
+    }>;
+    root?: JsonSchema;
+    declarations?: Map<string, string>;
+    inProgress?: Set<string>;
+    refNameByPointer?: Map<string, string>;
+    usedNames?: Set<string>;
+    currentSchemaName?: string;
+};
+export type SimpleDiscriminatedOneOfSchema<D extends string = string> = JsonSchemaObject & {
+    oneOf: (JsonSchemaObject & {
+        type: "object";
+        properties: {
+            [K in D]: JsonSchemaObject & {
+                type: "string";
+            };
+        } & {
+            [key: string]: JsonSchemaObject;
+        };
+    })[];
+    discriminator: {
+        propertyName: D;
+    };
+};

package/dist/types/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+export * from "./Types.js";
+export * from "./jsonSchemaToZod.js";
+export * from "./parsers/parseAllOf.js";
+export * from "./parsers/parseAnyOf.js";
+export * from "./parsers/parseArray.js";
+export * from "./parsers/parseBoolean.js";
+export * from "./parsers/parseConst.js";
+export * from "./parsers/parseDefault.js";
+export * from "./parsers/parseEnum.js";
+export * from "./parsers/parseIfThenElse.js";
+export * from "./parsers/parseMultipleType.js";
+export * from "./parsers/parseNot.js";
+export * from "./parsers/parseNull.js";
+export * from "./parsers/parseNullable.js";
+export * from "./parsers/parseNumber.js";
+export * from "./parsers/parseObject.js";
+export * from "./parsers/parseOneOf.js";
+export * from "./parsers/parseSchema.js";
+export * from "./parsers/parseSimpleDiscriminatedOneOf.js";
+export * from "./parsers/parseString.js";
+export * from "./utils/anyOrUnknown.js";
+export * from "./utils/half.js";
+export * from "./utils/jsdocs.js";
+export * from "./utils/omit.js";
+export * from "./utils/withMessage.js";
+export * from "./zodToJsonSchema.js";
+import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
+export default jsonSchemaToZod;

package/dist/types/jsonSchemaToZod.d.ts

@@ -0,0 +1,2 @@
+import { Options, JsonSchema } from "./Types.js";
+export declare const jsonSchemaToZod: (schema: JsonSchema, { module, name, type, noImport, ...rest }?: Options) => string;

package/dist/types/parsers/parseAllOf.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, JsonSchema, Refs } from "../Types.js";
+export declare function parseAllOf(schema: JsonSchemaObject & {
+    allOf: JsonSchema[];
+}, refs: Refs): string;

package/dist/types/parsers/parseAnyOf.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, JsonSchema, Refs } from "../Types.js";
+export declare const parseAnyOf: (schema: JsonSchemaObject & {
+    anyOf: JsonSchema[];
+}, refs: Refs) => string;

package/dist/types/parsers/parseArray.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, Refs } from "../Types.js";
+export declare const parseArray: (schema: JsonSchemaObject & {
+    type: "array";
+}, refs: Refs) => string;

package/dist/types/parsers/parseBoolean.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject } from "../Types.js";
+export declare const parseBoolean: (_schema: JsonSchemaObject & {
+    type: "boolean";
+}) => string;

package/dist/types/parsers/parseConst.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, Serializable } from "../Types.js";
+export declare const parseConst: (schema: JsonSchemaObject & {
+    const: Serializable;
+}) => string;

package/dist/types/parsers/parseDefault.d.ts

@@ -0,0 +1,2 @@
+import { JsonSchemaObject, Refs } from "../Types.js";
+export declare const parseDefault: (_schema: JsonSchemaObject, refs?: Refs) => string;

package/dist/types/parsers/parseEnum.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, Serializable } from "../Types.js";
+export declare const parseEnum: (schema: JsonSchemaObject & {
+    enum: Serializable[];
+}) => string;

package/dist/types/parsers/parseIfThenElse.d.ts

@@ -0,0 +1,6 @@
+import { JsonSchemaObject, JsonSchema, Refs } from "../Types.js";
+export declare const parseIfThenElse: (schema: JsonSchemaObject & {
+    if: JsonSchema;
+    then: JsonSchema;
+    else: JsonSchema;
+}, refs: Refs) => string;

package/dist/types/parsers/parseMultipleType.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, Refs } from "../Types.js";
+export declare const parseMultipleType: (schema: JsonSchemaObject & {
+    type: string[];
+}, refs: Refs) => string;

package/dist/types/parsers/parseNot.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, JsonSchema, Refs } from "../Types.js";
+export declare const parseNot: (schema: JsonSchemaObject & {
+    not: JsonSchema;
+}, refs: Refs) => string;

package/dist/types/parsers/parseNull.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject } from "../Types.js";
+export declare const parseNull: (_schema: JsonSchemaObject & {
+    type: "null";
+}) => string;

package/dist/types/parsers/parseNullable.d.ts

@@ -0,0 +1,7 @@
+import { JsonSchemaObject, Refs } from "../Types.js";
+/**
+ * For compatibility with open api 3.0 nullable
+ */
+export declare const parseNullable: (schema: JsonSchemaObject & {
+    nullable: true;
+}, refs: Refs) => string;

package/dist/types/parsers/parseNumber.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject } from "../Types.js";
+export declare const parseNumber: (schema: JsonSchemaObject & {
+    type: "number" | "integer";
+}) => string;

package/dist/types/parsers/parseObject.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, Refs } from "../Types.js";
+export declare function parseObject(objectSchema: JsonSchemaObject & {
+    type: "object";
+}, refs: Refs): string;

package/dist/types/parsers/parseOneOf.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject, JsonSchema, Refs } from "../Types.js";
+export declare const parseOneOf: (schema: JsonSchemaObject & {
+    oneOf: JsonSchema[];
+}, refs: Refs) => string;

package/dist/types/parsers/parseSchema.d.ts

@@ -0,0 +1,50 @@
+import { Refs, JsonSchemaObject, JsonSchema, Serializable, SimpleDiscriminatedOneOfSchema } from "../Types.js";
+export declare const parseSchema: (schema: JsonSchema, refs?: Refs, blockMeta?: boolean) => string;
+export declare const its: {
+    an: {
+        object: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            type: "object";
+        };
+        array: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            type: "array";
+        };
+        anyOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            anyOf: JsonSchema[];
+        };
+        allOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            allOf: JsonSchema[];
+        };
+        enum: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            enum: Serializable | Serializable[];
+        };
+    };
+    a: {
+        nullable: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            nullable: true;
+        };
+        multipleType: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            type: string[];
+        };
+        not: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            not: JsonSchema;
+        };
+        ref: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            $ref: string;
+        };
+        const: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            const: Serializable;
+        };
+        primitive: <T extends "string" | "number" | "integer" | "boolean" | "null">(x: JsonSchemaObject, p: T) => x is JsonSchemaObject & {
+            type: T;
+        };
+        conditional: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            if: JsonSchema;
+            then: JsonSchema;
+            else: JsonSchema;
+        };
+        simpleDiscriminatedOneOf: (x: JsonSchemaObject) => x is SimpleDiscriminatedOneOfSchema;
+        oneOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            oneOf: JsonSchema[];
+        };
+    };
+};

package/dist/types/parsers/parseSimpleDiscriminatedOneOf.d.ts

@@ -0,0 +1,2 @@
+import { SimpleDiscriminatedOneOfSchema, Refs } from "../Types.js";
+export declare const parseSimpleDiscriminatedOneOf: (schema: SimpleDiscriminatedOneOfSchema, refs: Refs) => string;

package/dist/types/parsers/parseString.d.ts

@@ -0,0 +1,4 @@
+import { JsonSchemaObject } from "../Types.js";
+export declare const parseString: (schema: JsonSchemaObject & {
+    type: "string";
+}) => string;

package/dist/types/utils/anyOrUnknown.d.ts

@@ -0,0 +1,9 @@
+import type { Refs } from "../Types.js";
+/**
+ * Returns "z.unknown()" if the useUnknown option is enabled, otherwise "z.any()".
+ * This helper is used throughout the library for fallback cases.
+ *
+ * @param refs - The refs object containing options
+ * @returns The appropriate Zod schema string
+ */
+export declare const anyOrUnknown: (refs?: Refs) => string;