@gabrielbryk/json-schema-to-zod 2.10.1 → 2.11.0

package/dist/cjs/utils/withMessage.js

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

package/dist/cjs/zodToJsonSchema.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * 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)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reconstructJsonSchema = reconstructJsonSchema;
-/**
- * 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
- */
-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/esm/core/emitZod.js

@@ -1,153 +0,0 @@
-import { parseSchema } from "../parsers/parseSchema.js";
-import { expandJsdocs } from "../utils/jsdocs.js";
-const orderDeclarations = (entries, dependencies) => {
-    const valueByName = new Map(entries);
-    const depGraph = new Map();
-    for (const [from, set] of dependencies.entries()) {
-        const onlyKnown = new Set();
-        for (const dep of set) {
-            if (valueByName.has(dep) && dep !== from) {
-                onlyKnown.add(dep);
-            }
-        }
-        if (onlyKnown.size)
-            depGraph.set(from, onlyKnown);
-    }
-    const names = Array.from(valueByName.keys());
-    for (const [name, value] of entries) {
-        const deps = depGraph.get(name) ?? new Set();
-        for (const candidate of names) {
-            if (candidate === name)
-                continue;
-            const matcher = new RegExp(`\\b${candidate}\\b`);
-            if (matcher.test(value)) {
-                deps.add(candidate);
-            }
-        }
-        if (deps.size)
-            depGraph.set(name, deps);
-    }
-    const ordered = [];
-    const perm = new Set();
-    const temp = new Set();
-    const visit = (name) => {
-        if (perm.has(name))
-            return;
-        if (temp.has(name)) {
-            temp.delete(name);
-            perm.add(name);
-            ordered.push(name);
-            return;
-        }
-        temp.add(name);
-        const deps = depGraph.get(name);
-        if (deps) {
-            for (const dep of deps) {
-                if (valueByName.has(dep)) {
-                    visit(dep);
-                }
-            }
-        }
-        temp.delete(name);
-        perm.add(name);
-        ordered.push(name);
-    };
-    for (const name of valueByName.keys()) {
-        visit(name);
-    }
-    const unique = [];
-    const seen = new Set();
-    for (const name of ordered) {
-        if (!seen.has(name)) {
-            seen.add(name);
-            unique.push(name);
-        }
-    }
-    return unique.map((name) => [name, valueByName.get(name)]);
-};
-export const emitZod = (analysis) => {
-    const { schema, options, refNameByPointer, usedNames, cycleRefNames, cycleComponentByName, } = analysis;
-    const { module, name, type, noImport, exportRefs, withMeta, ...rest } = options;
-    const declarations = new Map();
-    const dependencies = new Map();
-    const reserveName = (base) => {
-        let candidate = base;
-        let i = 1;
-        while (usedNames.has(candidate) || declarations.has(candidate)) {
-            candidate = `${base}${i}`;
-            i += 1;
-        }
-        usedNames.add(candidate);
-        return candidate;
-    };
-    const parsedSchema = parseSchema(schema, {
-        module,
-        name,
-        path: [],
-        seen: new Map(),
-        declarations,
-        dependencies,
-        inProgress: new Set(),
-        refNameByPointer,
-        usedNames,
-        root: schema,
-        currentSchemaName: name,
-        cycleRefNames,
-        cycleComponentByName,
-        refRegistry: analysis.refRegistry,
-        rootBaseUri: analysis.rootBaseUri,
-        ...rest,
-        withMeta,
-    });
-    const declarationBlock = declarations.size
-        ? orderDeclarations(Array.from(declarations.entries()), dependencies)
-            .flatMap(([refName, value]) => {
-            const shouldExport = exportRefs && module === "esm";
-            const isCycle = cycleRefNames.has(refName);
-            if (!isCycle) {
-                return [`${shouldExport ? "export " : ""}const ${refName} = ${value}`];
-            }
-            const baseName = `${refName}Def`;
-            const lines = [`const ${baseName} = ${value}`];
-            lines.push(`${shouldExport ? "export " : ""}const ${refName} = ${baseName}`);
-            return lines;
-        })
-            .join("\n")
-        : "";
-    const jsdocs = rest.withJsdocs && typeof schema === "object" && schema !== null && "description" in schema
-        ? expandJsdocs(String(schema.description ?? ""))
-        : "";
-    const lines = [];
-    if (module === "cjs" && !noImport) {
-        lines.push(`const { z } = require("zod")`);
-    }
-    if (module === "esm" && !noImport) {
-        lines.push(`import { z } from "zod"`);
-    }
-    if (declarationBlock) {
-        lines.push(declarationBlock);
-    }
-    if (module === "cjs") {
-        const payload = name ? `{ ${JSON.stringify(name)}: ${parsedSchema} }` : parsedSchema;
-        lines.push(`${jsdocs}module.exports = ${payload}`);
-    }
-    else if (module === "esm") {
-        const exportLine = `${jsdocs}export ${name ? `const ${name} =` : `default`} ${parsedSchema}`;
-        lines.push(exportLine);
-    }
-    else if (name) {
-        lines.push(`${jsdocs}const ${name} = ${parsedSchema}`);
-    }
-    else {
-        lines.push(`${jsdocs}${parsedSchema}`);
-    }
-    let typeLine;
-    if (type && name) {
-        const typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
-        typeLine = `export type ${typeName} = z.infer<typeof ${name}>`;
-    }
-    const joined = lines.filter(Boolean).join("\n\n");
-    const combined = typeLine ? `${joined}\n${typeLine}` : joined;
-    const shouldEndWithNewline = module === "esm" || module === "cjs";
-    return `${combined}${shouldEndWithNewline ? "\n" : ""}`;
-};

package/dist/esm/jsonSchemaToZod.js

@@ -1,6 +0,0 @@
-import { analyzeSchema } from "./core/analyzeSchema.js";
-import { emitZod } from "./core/emitZod.js";
-export const jsonSchemaToZod = (schema, options = {}) => {
-    const analysis = analyzeSchema(schema, options);
-    return emitZod(analysis);
-};

package/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/esm/parsers/parseAllOf.js

@@ -1,43 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-import { half } from "../utils/half.js";
-const originalIndexKey = "__originalIndex";
-const ensureOriginalIndex = (arr) => {
-    const newArr = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        if (typeof item === "boolean") {
-            newArr.push(item ? { [originalIndexKey]: i } : { [originalIndexKey]: i, not: {} });
-        }
-        else if (typeof item === "object" &&
-            item !== null &&
-            originalIndexKey in item) {
-            return arr;
-        }
-        else {
-            newArr.push({ ...item, [originalIndexKey]: i });
-        }
-    }
-    return newArr;
-};
-export function parseAllOf(schema, refs) {
-    if (schema.allOf.length === 0) {
-        return "z.never()";
-    }
-    else if (schema.allOf.length === 1) {
-        const item = schema.allOf[0];
-        return parseSchema(item, {
-            ...refs,
-            path: [
-                ...refs.path,
-                "allOf",
-                item[originalIndexKey] ?? 0,
-            ],
-        });
-    }
-    else {
-        const [left, right] = half(ensureOriginalIndex(schema.allOf));
-        return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
-            allOf: right,
-        }, refs)})`;
-    }
-}

package/dist/esm/parsers/parseAnyOf.js

@@ -1,14 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseAnyOf = (schema, refs) => {
-    return schema.anyOf.length
-        ? schema.anyOf.length === 1
-            ? parseSchema(schema.anyOf[0], {
-                ...refs,
-                path: [...refs.path, "anyOf", 0],
-            })
-            : `z.union([${schema.anyOf
-                .map((schema, i) => parseSchema(schema, { ...refs, path: [...refs.path, "anyOf", i] }))
-                .join(", ")}])`
-        : anyOrUnknown(refs);
-};

package/dist/esm/parsers/parseBoolean.js

@@ -1 +0,0 @@
-export const parseBoolean = () => "z.boolean()";

package/dist/esm/parsers/parseConst.js

@@ -1,3 +0,0 @@
-export const parseConst = (schema) => {
-    return `z.literal(${JSON.stringify(schema.const)})`;
-};

package/dist/esm/parsers/parseEnum.js

@@ -1,17 +0,0 @@
-export const parseEnum = (schema) => {
-    if (schema.enum.length === 0) {
-        return "z.never()";
-    }
-    else if (schema.enum.length === 1) {
-        // union does not work when there is only one element
-        return `z.literal(${JSON.stringify(schema.enum[0])})`;
-    }
-    else if (schema.enum.every((x) => typeof x === "string")) {
-        return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
-    }
-    else {
-        return `z.union([${schema.enum
-            .map((x) => `z.literal(${JSON.stringify(x)})`)
-            .join(", ")}])`;
-    }
-};

package/dist/esm/parsers/parseMultipleType.js

@@ -1,6 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseMultipleType = (schema, refs) => {
-    return `z.union([${schema.type
-        .map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true }))
-        .join(", ")}])`;
-};

package/dist/esm/parsers/parseNot.js

@@ -1,8 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseNot = (schema, refs) => {
-    return `${anyOrUnknown(refs)}.refine((value) => !${parseSchema(schema.not, {
-        ...refs,
-        path: [...refs.path, "not"],
-    })}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`;
-};

package/dist/esm/parsers/parseNull.js

@@ -1 +0,0 @@
-export const parseNull = () => "z.null()";

package/dist/esm/parsers/parseNullable.js

@@ -1,8 +0,0 @@
-import { omit } from "../utils/omit.js";
-import { parseSchema } from "./parseSchema.js";
-/**
- * For compatibility with open api 3.0 nullable
- */
-export const parseNullable = (schema, refs) => {
-    return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
-};

package/dist/esm/parsers/parseOneOf.js

@@ -1,49 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseOneOf = (schema, refs) => {
-    if (!schema.oneOf.length) {
-        return anyOrUnknown(refs);
-    }
-    if (schema.oneOf.length === 1) {
-        return parseSchema(schema.oneOf[0], {
-            ...refs,
-            path: [...refs.path, "oneOf", 0],
-        });
-    }
-    // Generate parsed schemas for each oneOf option
-    const parsedSchemas = schema.oneOf.map((s, i) => parseSchema(s, {
-        ...refs,
-        path: [...refs.path, "oneOf", i],
-    }));
-    // JSON Schema oneOf = exactly one must match (exclusive OR)
-    // Zod union = at least one must match (inclusive OR)
-    //
-    // By default, use simple z.union() which provides "at least one must match".
-    // This is more practical for most use cases, as strict oneOf enforcement
-    // often fails when schemas have overlapping base types.
-    //
-    // If strictOneOf is enabled, add superRefine to enforce "exactly one" constraint.
-    if (refs.strictOneOf) {
-        return `z.union([${parsedSchemas.join(", ")}]).superRefine((x, ctx) => {
-    const schemas = [${parsedSchemas.join(", ")}];
-    const errors = schemas.reduce<z.ZodError[]>(
-      (errors, schema) =>
-        ((result) =>
-          result.error ? [...errors, result.error] : errors)(
-          schema.safeParse(x),
-        ),
-      [],
-    );
-    if (schemas.length - errors.length !== 1) {
-      ctx.addIssue({
-        path: [],
-        code: "invalid_union",
-        errors: errors.map(e => e.issues),
-        message: "Invalid input: Should pass single schema",
-      });
-    }
-  })`;
-    }
-    // Default: use simple z.union() (at least one must match)
-    return `z.union([${parsedSchemas.join(", ")}])`;
-};

package/dist/esm/parsers/parseSimpleDiscriminatedOneOf.js

@@ -1,17 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseSimpleDiscriminatedOneOf = (schema, refs) => {
-    const discriminator = schema.discriminator.propertyName;
-    const options = schema.oneOf.map((option, i) => parseSchema(option, {
-        ...refs,
-        path: [...refs.path, "oneOf", i],
-    }));
-    return schema.oneOf.length
-        ? schema.oneOf.length === 1
-            ? parseSchema(schema.oneOf[0], {
-                ...refs,
-                path: [...refs.path, "oneOf", 0],
-            })
-            : `z.discriminatedUnion("${discriminator}", [${options.join(", ")}])`
-        : anyOrUnknown(refs);
-};

package/dist/esm/utils/anyOrUnknown.js

@@ -1,10 +0,0 @@
-/**
- * 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/jest.config.cjs

@@ -1,4 +0,0 @@
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-};

package/postcjs.cjs

@@ -1 +0,0 @@
-require("fs").writeFileSync("./dist/cjs/package.json", '{"type":"commonjs"}', "utf-8")

package/postesm.cjs

@@ -1 +0,0 @@
-require("fs").writeFileSync("./dist/esm/package.json", '{"type":"module"}', "utf-8")