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

package/dist/cjs/parsers/parseSchema.js

@@ -1,419 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.its = exports.parseSchema = void 0;
-const parseAnyOf_js_1 = require("./parseAnyOf.js");
-const parseBoolean_js_1 = require("./parseBoolean.js");
-const parseDefault_js_1 = require("./parseDefault.js");
-const parseMultipleType_js_1 = require("./parseMultipleType.js");
-const parseNot_js_1 = require("./parseNot.js");
-const parseNull_js_1 = require("./parseNull.js");
-const parseAllOf_js_1 = require("./parseAllOf.js");
-const parseArray_js_1 = require("./parseArray.js");
-const parseConst_js_1 = require("./parseConst.js");
-const parseEnum_js_1 = require("./parseEnum.js");
-const parseIfThenElse_js_1 = require("./parseIfThenElse.js");
-const parseNumber_js_1 = require("./parseNumber.js");
-const parseObject_js_1 = require("./parseObject.js");
-const parseString_js_1 = require("./parseString.js");
-const parseOneOf_js_1 = require("./parseOneOf.js");
-const parseSimpleDiscriminatedOneOf_js_1 = require("./parseSimpleDiscriminatedOneOf.js");
-const parseNullable_js_1 = require("./parseNullable.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const resolveUri_js_1 = require("../utils/resolveUri.js");
-const buildRefRegistry_js_1 = require("../utils/buildRefRegistry.js");
-const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
-    // Ensure ref bookkeeping exists so $ref declarations and getter-based recursion work
-    refs.root = refs.root ?? schema;
-    refs.rootBaseUri = refs.rootBaseUri ?? "root:///";
-    refs.declarations = refs.declarations ?? new Map();
-    refs.dependencies = refs.dependencies ?? new Map();
-    refs.inProgress = refs.inProgress ?? new Set();
-    refs.refNameByPointer = refs.refNameByPointer ?? new Map();
-    refs.usedNames = refs.usedNames ?? new Set();
-    if (typeof schema !== "object")
-        return schema ? (0, anyOrUnknown_js_1.anyOrUnknown)(refs) : "z.never()";
-    const parentBase = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
-    const baseUri = typeof schema.$id === "string" ? (0, resolveUri_js_1.resolveUri)(parentBase, schema.$id) : parentBase;
-    const dynamicAnchors = Array.isArray(refs.dynamicAnchors) ? [...refs.dynamicAnchors] : [];
-    if (typeof schema.$dynamicAnchor === "string") {
-        dynamicAnchors.push({
-            name: schema.$dynamicAnchor,
-            uri: baseUri,
-            path: refs.path,
-        });
-    }
-    if (refs.parserOverride) {
-        const custom = refs.parserOverride(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
-        if (typeof custom === "string") {
-            return custom;
-        }
-    }
-    let seen = refs.seen.get(schema);
-    if (seen) {
-        if (seen.r !== undefined) {
-            return seen.r;
-        }
-        if (refs.depth === undefined || seen.n >= refs.depth) {
-            return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
-        }
-        seen.n += 1;
-    }
-    else {
-        seen = { r: undefined, n: 0 };
-        refs.seen.set(schema, seen);
-    }
-    if (exports.its.a.ref(schema)) {
-        const parsedRef = parseRef(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
-        seen.r = parsedRef;
-        return parsedRef;
-    }
-    let parsed = selectParser(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
-    if (!blockMeta) {
-        if (!refs.withoutDescribes) {
-            parsed = addDescribes(schema, parsed, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
-        }
-        if (!refs.withoutDefaults) {
-            parsed = addDefaults(schema, parsed);
-        }
-        parsed = addAnnotations(schema, parsed);
-    }
-    seen.r = parsed;
-    return parsed;
-};
-exports.parseSchema = parseSchema;
-const parseRef = (schema, refs) => {
-    const refValue = schema.$dynamicRef ?? schema.$ref;
-    if (typeof refValue !== "string") {
-        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
-    }
-    const resolved = resolveRef(schema, refValue, refs);
-    if (!resolved) {
-        refs.onUnresolvedRef?.(refValue, refs.path);
-        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
-    }
-    const { schema: target, path, pointerKey } = resolved;
-    const refName = getOrCreateRefName(pointerKey, path, refs);
-    if (!refs.declarations.has(refName) && !refs.inProgress.has(refName)) {
-        refs.inProgress.add(refName);
-        const declaration = (0, exports.parseSchema)(target, {
-            ...refs,
-            path,
-            currentBaseUri: resolved.baseUri,
-            currentSchemaName: refName,
-            root: refs.root,
-        });
-        refs.inProgress.delete(refName);
-        refs.declarations.set(refName, declaration);
-    }
-    const current = refs.currentSchemaName;
-    if (current) {
-        const deps = refs.dependencies;
-        const set = deps.get(current) ?? new Set();
-        set.add(refName);
-        deps.set(current, set);
-    }
-    const currentComponent = refs.currentSchemaName
-        ? refs.cycleComponentByName?.get(refs.currentSchemaName)
-        : undefined;
-    const targetComponent = refs.cycleComponentByName?.get(refName);
-    const isSameCycle = currentComponent !== undefined &&
-        targetComponent !== undefined &&
-        currentComponent === targetComponent &&
-        refs.cycleRefNames?.has(refName);
-    // Only lazy if the ref stays inside the current strongly-connected component
-    // (or is currently being resolved). This avoids TDZ on true cycles while
-    // letting ordered, acyclic refs stay direct.
-    if (isSameCycle || refs.inProgress.has(refName)) {
-        const inObjectProperty = refs.path.includes("properties") ||
-            refs.path.includes("patternProperties") ||
-            refs.path.includes("additionalProperties");
-        if (inObjectProperty && refName === refs.currentSchemaName) {
-            // Getter properties defer evaluation, so a direct reference avoids extra lazies
-            // for self-recursion.
-            return refName;
-        }
-        return `z.lazy(() => ${refName})`;
-    }
-    return refName;
-};
-const addDescribes = (schema, parsed, refs) => {
-    // Use .meta() for richer metadata when withMeta is enabled
-    if (refs?.withMeta) {
-        const meta = {};
-        if (schema.$id)
-            meta.id = schema.$id;
-        if (schema.title)
-            meta.title = schema.title;
-        if (schema.description)
-            meta.description = schema.description;
-        if (schema.examples)
-            meta.examples = schema.examples;
-        if (schema.deprecated)
-            meta.deprecated = schema.deprecated;
-        if (Object.keys(meta).length > 0) {
-            parsed += `.meta(${JSON.stringify(meta)})`;
-        }
-    }
-    else if (schema.description) {
-        parsed += `.describe(${JSON.stringify(schema.description)})`;
-    }
-    return parsed;
-};
-const resolveRef = (schemaNode, ref, refs) => {
-    const base = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
-    // Handle dynamicRef lookup via dynamicAnchors stack
-    const isDynamic = typeof schemaNode.$dynamicRef === "string";
-    if (isDynamic && refs.dynamicAnchors && ref.startsWith("#")) {
-        const name = ref.slice(1);
-        for (let i = refs.dynamicAnchors.length - 1; i >= 0; i -= 1) {
-            const entry = refs.dynamicAnchors[i];
-            if (entry.name === name) {
-                const key = `${entry.uri}#${name}`;
-                const target = refs.refRegistry?.get(key);
-                if (target) {
-                    return { schema: target.schema, path: target.path, baseUri: target.baseUri, pointerKey: key };
-                }
-            }
-        }
-    }
-    // Resolve URI against base
-    const resolvedUri = (0, resolveUri_js_1.resolveUri)(base, ref);
-    const [uriBase, fragment] = resolvedUri.split("#");
-    const key = fragment ? `${uriBase}#${fragment}` : uriBase;
-    let regEntry = refs.refRegistry?.get(key);
-    if (regEntry) {
-        return { schema: regEntry.schema, path: regEntry.path, baseUri: regEntry.baseUri, pointerKey: key };
-    }
-    // Legacy recursive ref: treat as dynamic to __recursive__
-    if (schemaNode.$recursiveRef) {
-        const recursiveKey = `${base}#__recursive__`;
-        regEntry = refs.refRegistry?.get(recursiveKey);
-        if (regEntry) {
-            return {
-                schema: regEntry.schema,
-                path: regEntry.path,
-                baseUri: regEntry.baseUri,
-                pointerKey: recursiveKey,
-            };
-        }
-    }
-    // External resolver hook
-    const extBase = uriBaseFromRef(resolvedUri);
-    if (refs.resolveExternalRef && extBase && !isLocalBase(extBase, refs.rootBaseUri ?? "")) {
-        const loaded = refs.resolveExternalRef(extBase);
-        if (loaded) {
-            // If async resolver is used synchronously here, it will be ignored; keep simple sync for now
-            const maybePromise = loaded;
-            const schema = typeof maybePromise.then === "function"
-                ? undefined
-                : loaded;
-            if (schema) {
-                const { registry } = (0, buildRefRegistry_js_1.buildRefRegistry)(schema, extBase);
-                registry.forEach((entry, k) => refs.refRegistry?.set(k, entry));
-                regEntry = refs.refRegistry?.get(key);
-                if (regEntry) {
-                    return {
-                        schema: regEntry.schema,
-                        path: regEntry.path,
-                        baseUri: regEntry.baseUri,
-                        pointerKey: key,
-                    };
-                }
-            }
-        }
-    }
-    // Backward compatibility: JSON Pointer into root
-    if (refs.root && ref.startsWith("#/")) {
-        const rawSegments = ref
-            .slice(2)
-            .split("/")
-            .filter((segment) => segment.length > 0)
-            .map(decodePointerSegment);
-        let current = refs.root;
-        for (const segment of rawSegments) {
-            if (typeof current !== "object" || current === null)
-                return undefined;
-            current = current[segment];
-        }
-        return { schema: current, path: rawSegments, baseUri: base, pointerKey: ref };
-    }
-    return undefined;
-};
-const decodePointerSegment = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
-const uriBaseFromRef = (resolvedUri) => {
-    const hashIdx = resolvedUri.indexOf("#");
-    return hashIdx === -1 ? resolvedUri : resolvedUri.slice(0, hashIdx);
-};
-const isLocalBase = (base, rootBase) => {
-    if (!rootBase)
-        return false;
-    return base === rootBase;
-};
-const getOrCreateRefName = (pointer, path, refs) => {
-    if (refs.refNameByPointer?.has(pointer)) {
-        return refs.refNameByPointer.get(pointer);
-    }
-    const preferred = buildNameFromPath(path, refs.usedNames);
-    refs.refNameByPointer?.set(pointer, preferred);
-    refs.usedNames?.add(preferred);
-    return preferred;
-};
-const buildNameFromPath = (path, used) => {
-    const filtered = path
-        .map((segment, idx) => {
-        if (idx === 0 && (segment === "$defs" || segment === "definitions")) {
-            return undefined; // root-level defs prefix is redundant for naming
-        }
-        if (segment === "properties")
-            return undefined; // skip noisy properties segment
-        if (segment === "$defs" || segment === "definitions")
-            return "Defs";
-        return segment;
-    })
-        .filter((segment) => segment !== undefined);
-    const base = filtered.length
-        ? filtered
-            .map((segment) => typeof segment === "number"
-            ? `Ref${segment}`
-            : segment
-                .toString()
-                .replace(/[^a-zA-Z0-9_$]/g, " ")
-                .split(" ")
-                .filter(Boolean)
-                .map(capitalize)
-                .join(""))
-            .join("")
-        : "Ref";
-    const sanitized = sanitizeIdentifier(base || "Ref");
-    if (!used || !used.has(sanitized))
-        return sanitized;
-    let counter = 2;
-    let candidate = `${sanitized}${counter}`;
-    while (used.has(candidate)) {
-        counter += 1;
-        candidate = `${sanitized}${counter}`;
-    }
-    return candidate;
-};
-const sanitizeIdentifier = (value) => {
-    const cleaned = value.replace(/^[^a-zA-Z_$]+/, "").replace(/[^a-zA-Z0-9_$]/g, "");
-    return cleaned || "Ref";
-};
-const capitalize = (value) => value.length ? value[0].toUpperCase() + value.slice(1) : value;
-const addDefaults = (schema, parsed) => {
-    if (schema.default !== undefined) {
-        parsed += `.default(${JSON.stringify(schema.default)})`;
-    }
-    return parsed;
-};
-const addAnnotations = (schema, parsed) => {
-    if (schema.readOnly) {
-        parsed += ".readonly()";
-    }
-    return parsed;
-};
-const selectParser = (schema, refs) => {
-    if (exports.its.a.nullable(schema)) {
-        return (0, parseNullable_js_1.parseNullable)(schema, refs);
-    }
-    else if (exports.its.an.object(schema)) {
-        return (0, parseObject_js_1.parseObject)(schema, refs);
-    }
-    else if (exports.its.an.array(schema)) {
-        return (0, parseArray_js_1.parseArray)(schema, refs);
-    }
-    else if (exports.its.an.anyOf(schema)) {
-        return (0, parseAnyOf_js_1.parseAnyOf)(schema, refs);
-    }
-    else if (exports.its.an.allOf(schema)) {
-        return (0, parseAllOf_js_1.parseAllOf)(schema, refs);
-    }
-    else if (exports.its.a.simpleDiscriminatedOneOf(schema)) {
-        return (0, parseSimpleDiscriminatedOneOf_js_1.parseSimpleDiscriminatedOneOf)(schema, refs);
-    }
-    else if (exports.its.a.oneOf(schema)) {
-        return (0, parseOneOf_js_1.parseOneOf)(schema, refs);
-    }
-    else if (exports.its.a.not(schema)) {
-        return (0, parseNot_js_1.parseNot)(schema, refs);
-    }
-    else if (exports.its.an.enum(schema)) {
-        return (0, parseEnum_js_1.parseEnum)(schema); //<-- needs to come before primitives
-    }
-    else if (exports.its.a.const(schema)) {
-        return (0, parseConst_js_1.parseConst)(schema);
-    }
-    else if (exports.its.a.multipleType(schema)) {
-        return (0, parseMultipleType_js_1.parseMultipleType)(schema, refs);
-    }
-    else if (exports.its.a.primitive(schema, "string")) {
-        return (0, parseString_js_1.parseString)(schema, refs);
-    }
-    else if (exports.its.a.primitive(schema, "number") ||
-        exports.its.a.primitive(schema, "integer")) {
-        return (0, parseNumber_js_1.parseNumber)(schema);
-    }
-    else if (exports.its.a.primitive(schema, "boolean")) {
-        return (0, parseBoolean_js_1.parseBoolean)();
-    }
-    else if (exports.its.a.primitive(schema, "null")) {
-        return (0, parseNull_js_1.parseNull)();
-    }
-    else if (exports.its.a.conditional(schema)) {
-        return (0, parseIfThenElse_js_1.parseIfThenElse)(schema, refs);
-    }
-    else {
-        return (0, parseDefault_js_1.parseDefault)(schema, refs);
-    }
-};
-exports.its = {
-    an: {
-        object: (x) => x.type === "object",
-        array: (x) => x.type === "array",
-        anyOf: (x) => x.anyOf !== undefined,
-        allOf: (x) => x.allOf !== undefined,
-        enum: (x) => x.enum !== undefined,
-    },
-    a: {
-        nullable: (x) => x.nullable === true,
-        multipleType: (x) => Array.isArray(x.type),
-        not: (x) => x.not !== undefined,
-        ref: (x) => typeof x.$ref === "string" || typeof x.$dynamicRef === "string",
-        const: (x) => x.const !== undefined,
-        primitive: (x, p) => x.type === p,
-        conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),
-        simpleDiscriminatedOneOf: (x) => {
-            if (!x.oneOf ||
-                !Array.isArray(x.oneOf) ||
-                x.oneOf.length === 0 ||
-                !x.discriminator ||
-                typeof x.discriminator !== "object" ||
-                !("propertyName" in x.discriminator) ||
-                typeof x.discriminator.propertyName !== "string") {
-                return false;
-            }
-            const discriminatorProp = x.discriminator.propertyName;
-            return x.oneOf.every((schema) => {
-                if (!schema ||
-                    typeof schema !== "object" ||
-                    schema.type !== "object" ||
-                    !schema.properties ||
-                    typeof schema.properties !== "object" ||
-                    !(discriminatorProp in schema.properties)) {
-                    return false;
-                }
-                const property = schema.properties[discriminatorProp];
-                return (property &&
-                    typeof property === "object" &&
-                    (property.type === undefined || property.type === "string") &&
-                    // Ensure discriminator has a constant value (const or single-value enum)
-                    (property.const !== undefined ||
-                        (property.enum && Array.isArray(property.enum) && property.enum.length === 1)) &&
-                    // Ensure discriminator property is required
-                    Array.isArray(schema.required) &&
-                    schema.required.includes(discriminatorProp));
-            });
-        },
-        oneOf: (x) => x.oneOf !== undefined,
-    },
-};

package/dist/cjs/parsers/parseSimpleDiscriminatedOneOf.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSimpleDiscriminatedOneOf = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseSimpleDiscriminatedOneOf = (schema, refs) => {
-    const discriminator = schema.discriminator.propertyName;
-    const options = schema.oneOf.map((option, i) => (0, parseSchema_js_1.parseSchema)(option, {
-        ...refs,
-        path: [...refs.path, "oneOf", i],
-    }));
-    return schema.oneOf.length
-        ? schema.oneOf.length === 1
-            ? (0, parseSchema_js_1.parseSchema)(schema.oneOf[0], {
-                ...refs,
-                path: [...refs.path, "oneOf", 0],
-            })
-            : `z.discriminatedUnion("${discriminator}", [${options.join(", ")}])`
-        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
-};
-exports.parseSimpleDiscriminatedOneOf = parseSimpleDiscriminatedOneOf;