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

package/dist/esm/parsers/parseObject.js

@@ -1,11 +1,14 @@
-import { parseAnyOf } from "./parseAnyOf.js";
-import { parseOneOf } from "./parseOneOf.js";
-import { its, parseSchema } from "./parseSchema.js";
-import { parseAllOf } from "./parseAllOf.js";
-import { parseIfThenElse } from "./parseIfThenElse.js";
-import { addJsdocs } from "../utils/jsdocs.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export function parseObject(objectSchema, refs) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseObject = parseObject;
+const parseAnyOf_js_1 = require("./parseAnyOf.js");
+const parseOneOf_js_1 = require("./parseOneOf.js");
+const parseSchema_js_1 = require("./parseSchema.js");
+const parseAllOf_js_1 = require("./parseAllOf.js");
+const parseIfThenElse_js_1 = require("./parseIfThenElse.js");
+const jsdocs_js_1 = require("../utils/jsdocs.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+function parseObject(objectSchema, refs) {
     let properties = undefined;
     if (objectSchema.properties) {
         if (!Object.keys(objectSchema.properties).length) {
@@ -16,7 +19,7 @@ export function parseObject(objectSchema, refs) {
             properties += Object.keys(objectSchema.properties)
                 .map((key) => {
                 const propSchema = objectSchema.properties[key];
-                const parsedProp = parseSchema(propSchema, {
+                const parsedProp = (0, parseSchema_js_1.parseSchema)(propSchema, {
                     ...refs,
                     path: [...refs.path, "properties", key],
                 });
@@ -32,7 +35,7 @@ export function parseObject(objectSchema, refs) {
                     ? `get ${JSON.stringify(key)}(){ return ${valueWithOptional} }`
                     : `${JSON.stringify(key)}: ${valueWithOptional}`;
                 if (refs.withJsdocs && typeof propSchema === "object") {
-                    result = addJsdocs(propSchema, result);
+                    result = (0, jsdocs_js_1.addJsdocs)(propSchema, result);
                 }
                 return result;
             })
@@ -41,7 +44,7 @@ export function parseObject(objectSchema, refs) {
         }
     }
     const additionalProperties = objectSchema.additionalProperties !== undefined
-        ? parseSchema(objectSchema.additionalProperties, {
+        ? (0, parseSchema_js_1.parseSchema)(objectSchema.additionalProperties, {
             ...refs,
             path: [...refs.path, "additionalProperties"],
         })
@@ -52,7 +55,7 @@ export function parseObject(objectSchema, refs) {
         const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
             return [
                 key,
-                parseSchema(value, {
+                (0, parseSchema_js_1.parseSchema)(value, {
                     ...refs,
                     path: [...refs.path, "patternProperties", key],
                 }),
@@ -151,7 +154,7 @@ export function parseObject(objectSchema, refs) {
     // Check if there will be an .and() call that adds properties from oneOf/anyOf/allOf/if-then-else
     // In that case, we should NOT use .strict() because it will reject the additional keys
     // before the union gets a chance to validate them.
-    const hasCompositionKeywords = its.an.anyOf(objectSchema) || its.a.oneOf(objectSchema) || its.an.allOf(objectSchema) || its.a.conditional(objectSchema);
+    const hasCompositionKeywords = parseSchema_js_1.its.an.anyOf(objectSchema) || parseSchema_js_1.its.a.oneOf(objectSchema) || parseSchema_js_1.its.an.allOf(objectSchema) || parseSchema_js_1.its.a.conditional(objectSchema);
     let output = properties
         ? patternProperties
             ? properties + patternProperties
@@ -167,12 +170,12 @@ export function parseObject(objectSchema, refs) {
             ? patternProperties
             : additionalProperties
                 ? `z.record(z.string(), ${additionalProperties})`
-                : `z.record(z.string(), ${anyOrUnknown(refs)})`;
+                : `z.record(z.string(), ${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`;
     if (unevaluated === false && properties && !hasCompositionKeywords) {
         output += ".strict()";
     }
     else if (unevaluated && typeof unevaluated !== 'boolean') {
-        const unevaluatedSchema = parseSchema(unevaluated, {
+        const unevaluatedSchema = (0, parseSchema_js_1.parseSchema)(unevaluated, {
             ...refs,
             path: [...refs.path, "unevaluatedProperties"],
         });
@@ -193,8 +196,8 @@ export function parseObject(objectSchema, refs) {
   }
 })`;
     }
-    if (its.an.anyOf(objectSchema)) {
-        output += `.and(${parseAnyOf({
+    if (parseSchema_js_1.its.an.anyOf(objectSchema)) {
+        output += `.and(${(0, parseAnyOf_js_1.parseAnyOf)({
             ...objectSchema,
             anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
                 !x.type &&
@@ -203,8 +206,8 @@ export function parseObject(objectSchema, refs) {
                 : x),
         }, refs)})`;
     }
-    if (its.a.oneOf(objectSchema)) {
-        output += `.and(${parseOneOf({
+    if (parseSchema_js_1.its.a.oneOf(objectSchema)) {
+        output += `.and(${(0, parseOneOf_js_1.parseOneOf)({
             ...objectSchema,
             oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
                 !x.type &&
@@ -213,8 +216,8 @@ export function parseObject(objectSchema, refs) {
                 : x),
         }, refs)})`;
     }
-    if (its.an.allOf(objectSchema)) {
-        output += `.and(${parseAllOf({
+    if (parseSchema_js_1.its.an.allOf(objectSchema)) {
+        output += `.and(${(0, parseAllOf_js_1.parseAllOf)({
             ...objectSchema,
             allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
                 !x.type &&
@@ -224,8 +227,8 @@ export function parseObject(objectSchema, refs) {
         }, refs)})`;
     }
     // Handle if/then/else conditionals on object schemas
-    if (its.a.conditional(objectSchema)) {
-        output += `.and(${parseIfThenElse(objectSchema, refs)})`;
+    if (parseSchema_js_1.its.a.conditional(objectSchema)) {
+        output += `.and(${(0, parseIfThenElse_js_1.parseIfThenElse)(objectSchema, refs)})`;
     }
     // propertyNames
     if (objectSchema.propertyNames) {
@@ -234,7 +237,7 @@ export function parseObject(objectSchema, refs) {
             objectSchema.propertyNames.pattern
             ? { ...objectSchema.propertyNames, type: "string" }
             : objectSchema.propertyNames;
-        const propNameSchema = parseSchema(normalizedPropNames, {
+        const propNameSchema = (0, parseSchema_js_1.parseSchema)(normalizedPropNames, {
             ...refs,
             path: [...refs.path, "propertyNames"],
         });
@@ -259,7 +262,7 @@ export function parseObject(objectSchema, refs) {
             output += `.superRefine((obj, ctx) => {
   ${entries
                 .map(([key, schema], idx) => {
-                const parsed = parseSchema(schema, { ...refs, path: [...refs.path, "dependentSchemas", key] });
+                const parsed = (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "dependentSchemas", key] });
                 return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(key)})) {
     const result = ${parsed}.safeParse(obj);
     if (!result.success) {
@@ -268,6 +271,30 @@ export 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/esm/parsers/parseOneOf.js

@@ -1,17 +1,20 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseOneOf = (schema, refs) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOneOf = void 0;
+const parseSchema_js_1 = require("./parseSchema.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+const parseOneOf = (schema, refs) => {
     if (!schema.oneOf.length) {
-        return anyOrUnknown(refs);
+        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
     }
     if (schema.oneOf.length === 1) {
-        return parseSchema(schema.oneOf[0], {
+        return (0, parseSchema_js_1.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, {
+    const parsedSchemas = schema.oneOf.map((s, i) => (0, parseSchema_js_1.parseSchema)(s, {
         ...refs,
         path: [...refs.path, "oneOf", i],
     }));
@@ -47,3 +50,4 @@ export const parseOneOf = (schema, refs) => {
     // Default: use simple z.union() (at least one must match)
     return `z.union([${parsedSchemas.join(", ")}])`;
 };
+exports.parseOneOf = parseOneOf;

package/dist/esm/parsers/parseSchema.js

@@ -1,30 +1,34 @@
-import { parseAnyOf } from "./parseAnyOf.js";
-import { parseBoolean } from "./parseBoolean.js";
-import { parseDefault } from "./parseDefault.js";
-import { parseMultipleType } from "./parseMultipleType.js";
-import { parseNot } from "./parseNot.js";
-import { parseNull } from "./parseNull.js";
-import { parseAllOf } from "./parseAllOf.js";
-import { parseArray } from "./parseArray.js";
-import { parseConst } from "./parseConst.js";
-import { parseEnum } from "./parseEnum.js";
-import { parseIfThenElse } from "./parseIfThenElse.js";
-import { parseNumber } from "./parseNumber.js";
-import { parseObject } from "./parseObject.js";
-import { parseString } from "./parseString.js";
-import { parseOneOf } from "./parseOneOf.js";
-import { parseSimpleDiscriminatedOneOf } from "./parseSimpleDiscriminatedOneOf.js";
-import { parseNullable } from "./parseNullable.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
+"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 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();
     if (typeof schema !== "object")
-        return schema ? anyOrUnknown(refs) : "z.never()";
+        return schema ? (0, anyOrUnknown_js_1.anyOrUnknown)(refs) : "z.never()";
     if (refs.parserOverride) {
         const custom = refs.parserOverride(schema, refs);
         if (typeof custom === "string") {
@@ -37,7 +41,7 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
             return seen.r;
         }
         if (refs.depth === undefined || seen.n >= refs.depth) {
-            return anyOrUnknown(refs);
+            return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
         }
         seen.n += 1;
     }
@@ -45,7 +49,7 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
         seen = { r: undefined, n: 0 };
         refs.seen.set(schema, seen);
     }
-    if (its.a.ref(schema)) {
+    if (exports.its.a.ref(schema)) {
         const parsedRef = parseRef(schema, refs);
         seen.r = parsedRef;
         return parsedRef;
@@ -63,16 +67,17 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
     seen.r = parsed;
     return parsed;
 };
+exports.parseSchema = parseSchema;
 const parseRef = (schema, refs) => {
     const resolved = resolveRef(refs.root, schema.$ref);
     if (!resolved) {
-        return anyOrUnknown(refs);
+        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
     }
     const { schema: target, path } = resolved;
     const refName = getOrCreateRefName(schema.$ref, path, refs);
     if (!refs.declarations.has(refName) && !refs.inProgress.has(refName)) {
         refs.inProgress.add(refName);
-        const declaration = parseSchema(target, {
+        const declaration = (0, exports.parseSchema)(target, {
             ...refs,
             path,
             currentSchemaName: refName,
@@ -81,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) => {
@@ -175,60 +201,60 @@ const addAnnotations = (schema, parsed) => {
     return parsed;
 };
 const selectParser = (schema, refs) => {
-    if (its.a.nullable(schema)) {
-        return parseNullable(schema, refs);
+    if (exports.its.a.nullable(schema)) {
+        return (0, parseNullable_js_1.parseNullable)(schema, refs);
     }
-    else if (its.an.object(schema)) {
-        return parseObject(schema, refs);
+    else if (exports.its.an.object(schema)) {
+        return (0, parseObject_js_1.parseObject)(schema, refs);
     }
-    else if (its.an.array(schema)) {
-        return parseArray(schema, refs);
+    else if (exports.its.an.array(schema)) {
+        return (0, parseArray_js_1.parseArray)(schema, refs);
     }
-    else if (its.an.anyOf(schema)) {
-        return parseAnyOf(schema, refs);
+    else if (exports.its.an.anyOf(schema)) {
+        return (0, parseAnyOf_js_1.parseAnyOf)(schema, refs);
     }
-    else if (its.an.allOf(schema)) {
-        return parseAllOf(schema, refs);
+    else if (exports.its.an.allOf(schema)) {
+        return (0, parseAllOf_js_1.parseAllOf)(schema, refs);
     }
-    else if (its.a.simpleDiscriminatedOneOf(schema)) {
-        return parseSimpleDiscriminatedOneOf(schema, refs);
+    else if (exports.its.a.simpleDiscriminatedOneOf(schema)) {
+        return (0, parseSimpleDiscriminatedOneOf_js_1.parseSimpleDiscriminatedOneOf)(schema, refs);
     }
-    else if (its.a.oneOf(schema)) {
-        return parseOneOf(schema, refs);
+    else if (exports.its.a.oneOf(schema)) {
+        return (0, parseOneOf_js_1.parseOneOf)(schema, refs);
     }
-    else if (its.a.not(schema)) {
-        return parseNot(schema, refs);
+    else if (exports.its.a.not(schema)) {
+        return (0, parseNot_js_1.parseNot)(schema, refs);
     }
-    else if (its.an.enum(schema)) {
-        return parseEnum(schema); //<-- needs to come before primitives
+    else if (exports.its.an.enum(schema)) {
+        return (0, parseEnum_js_1.parseEnum)(schema); //<-- needs to come before primitives
     }
-    else if (its.a.const(schema)) {
-        return parseConst(schema);
+    else if (exports.its.a.const(schema)) {
+        return (0, parseConst_js_1.parseConst)(schema);
     }
-    else if (its.a.multipleType(schema)) {
-        return parseMultipleType(schema, refs);
+    else if (exports.its.a.multipleType(schema)) {
+        return (0, parseMultipleType_js_1.parseMultipleType)(schema, refs);
     }
-    else if (its.a.primitive(schema, "string")) {
-        return parseString(schema);
+    else if (exports.its.a.primitive(schema, "string")) {
+        return (0, parseString_js_1.parseString)(schema, refs);
     }
-    else if (its.a.primitive(schema, "number") ||
-        its.a.primitive(schema, "integer")) {
-        return parseNumber(schema);
+    else if (exports.its.a.primitive(schema, "number") ||
+        exports.its.a.primitive(schema, "integer")) {
+        return (0, parseNumber_js_1.parseNumber)(schema);
     }
-    else if (its.a.primitive(schema, "boolean")) {
-        return parseBoolean(schema);
+    else if (exports.its.a.primitive(schema, "boolean")) {
+        return (0, parseBoolean_js_1.parseBoolean)(schema);
     }
-    else if (its.a.primitive(schema, "null")) {
-        return parseNull(schema);
+    else if (exports.its.a.primitive(schema, "null")) {
+        return (0, parseNull_js_1.parseNull)(schema);
     }
-    else if (its.a.conditional(schema)) {
-        return parseIfThenElse(schema, refs);
+    else if (exports.its.a.conditional(schema)) {
+        return (0, parseIfThenElse_js_1.parseIfThenElse)(schema, refs);
     }
     else {
-        return parseDefault(schema, refs);
+        return (0, parseDefault_js_1.parseDefault)(schema, refs);
     }
 };
-export const its = {
+exports.its = {
     an: {
         object: (x) => x.type === "object",
         array: (x) => x.type === "array",

package/dist/esm/parsers/parseSimpleDiscriminatedOneOf.js

@@ -1,17 +1,21 @@
-import { parseSchema } from "./parseSchema.js";
-import { anyOrUnknown } from "../utils/anyOrUnknown.js";
-export const parseSimpleDiscriminatedOneOf = (schema, refs) => {
+"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) => parseSchema(option, {
+    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
-            ? parseSchema(schema.oneOf[0], {
+            ? (0, parseSchema_js_1.parseSchema)(schema.oneOf[0], {
                 ...refs,
                 path: [...refs.path, "oneOf", 0],
             })
             : `z.discriminatedUnion("${discriminator}", [${options.join(", ")}])`
-        : anyOrUnknown(refs);
+        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
 };
+exports.parseSimpleDiscriminatedOneOf = parseSimpleDiscriminatedOneOf;