@gabrielbryk/json-schema-to-zod 2.7.2

package/dist/cjs/parsers/parseNull.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNull = void 0;
+const parseNull = (_schema) => {
+    return "z.null()";
+};
+exports.parseNull = parseNull;

package/dist/cjs/parsers/parseNullable.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullable = void 0;
+const omit_js_1 = require("../utils/omit.js");
+const parseSchema_js_1 = require("./parseSchema.js");
+/**
+ * For compatibility with open api 3.0 nullable
+ */
+const parseNullable = (schema, refs) => {
+    return `${(0, parseSchema_js_1.parseSchema)((0, omit_js_1.omit)(schema, "nullable"), refs, true)}.nullable()`;
+};
+exports.parseNullable = parseNullable;

package/dist/cjs/parsers/parseNumber.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumber = void 0;
+const withMessage_js_1 = require("../utils/withMessage.js");
+const parseNumber = (schema) => {
+    let r = "z.number()";
+    if (schema.type === "integer") {
+        r += (0, withMessage_js_1.withMessage)(schema, "type", () => [".int(", ")"]);
+    }
+    else {
+        r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+            if (value === "int64") {
+                return [".int(", ")"];
+            }
+        });
+    }
+    r += (0, withMessage_js_1.withMessage)(schema, "multipleOf", ({ value, json }) => {
+        if (value === 1) {
+            if (r.startsWith("z.number().int(")) {
+                return;
+            }
+            return [".int(", ")"];
+        }
+        return [`.multipleOf(${json}`, ", ", ")"];
+    });
+    if (typeof schema.minimum === "number") {
+        if (schema.exclusiveMinimum === true) {
+            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => [
+                `.gt(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+        else {
+            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => [
+                `.gte(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+    }
+    else if (typeof schema.exclusiveMinimum === "number") {
+        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => [
+            `.gt(${json}`,
+            ", ",
+            ")",
+        ]);
+    }
+    if (typeof schema.maximum === "number") {
+        if (schema.exclusiveMaximum === true) {
+            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => [
+                `.lt(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+        else {
+            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => [
+                `.lte(${json}`,
+                ", ",
+                ")",
+            ]);
+        }
+    }
+    else if (typeof schema.exclusiveMaximum === "number") {
+        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => [
+            `.lt(${json}`,
+            ", ",
+            ")",
+        ]);
+    }
+    return r;
+};
+exports.parseNumber = parseNumber;

package/dist/cjs/parsers/parseObject.js

@@ -0,0 +1,286 @@
+"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) {
+            properties = "z.object({})";
+        }
+        else {
+            properties = "z.object({ ";
+            properties += Object.keys(objectSchema.properties)
+                .map((key) => {
+                const propSchema = objectSchema.properties[key];
+                const parsedProp = (0, parseSchema_js_1.parseSchema)(propSchema, {
+                    ...refs,
+                    path: [...refs.path, "properties", key],
+                });
+                const hasDefault = typeof propSchema === "object" && propSchema.default !== undefined;
+                const required = Array.isArray(objectSchema.required)
+                    ? objectSchema.required.includes(key)
+                    : typeof propSchema === "object" && propSchema.required === true;
+                const optional = !hasDefault && !required;
+                const valueWithOptional = optional
+                    ? `${parsedProp}.optional()`
+                    : parsedProp;
+                let result = shouldUseGetter(valueWithOptional, refs)
+                    ? `get ${JSON.stringify(key)}(){ return ${valueWithOptional} }`
+                    : `${JSON.stringify(key)}: ${valueWithOptional}`;
+                if (refs.withJsdocs && typeof propSchema === "object") {
+                    result = (0, jsdocs_js_1.addJsdocs)(propSchema, result);
+                }
+                return result;
+            })
+                .join(", ");
+            properties += " })";
+        }
+    }
+    const additionalProperties = objectSchema.additionalProperties !== undefined
+        ? (0, parseSchema_js_1.parseSchema)(objectSchema.additionalProperties, {
+            ...refs,
+            path: [...refs.path, "additionalProperties"],
+        })
+        : undefined;
+    const unevaluated = objectSchema.unevaluatedProperties;
+    let patternProperties = undefined;
+    if (objectSchema.patternProperties) {
+        const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
+            return [
+                key,
+                (0, parseSchema_js_1.parseSchema)(value, {
+                    ...refs,
+                    path: [...refs.path, "patternProperties", key],
+                }),
+            ];
+        }, {}));
+        patternProperties = "";
+        if (properties) {
+            if (additionalProperties) {
+                patternProperties += `.catchall(z.union([${[
+                    ...Object.values(parsedPatternProperties),
+                    additionalProperties,
+                ].join(", ")}]))`;
+            }
+            else if (Object.keys(parsedPatternProperties).length > 1) {
+                patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+            }
+            else {
+                patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
+            }
+        }
+        else {
+            if (additionalProperties) {
+                patternProperties += `z.record(z.string(), z.union([${[
+                    ...Object.values(parsedPatternProperties),
+                    additionalProperties,
+                ].join(", ")}]))`;
+            }
+            else if (Object.keys(parsedPatternProperties).length > 1) {
+                patternProperties += `z.record(z.string(), z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+            }
+            else {
+                patternProperties += `z.record(z.string(), ${Object.values(parsedPatternProperties)})`;
+            }
+        }
+        patternProperties += ".superRefine((value, ctx) => {\n";
+        patternProperties += "for (const key in value) {\n";
+        if (additionalProperties) {
+            if (objectSchema.properties) {
+                patternProperties += `let evaluated = [${Object.keys(objectSchema.properties)
+                    .map((key) => JSON.stringify(key))
+                    .join(", ")}].includes(key)\n`;
+            }
+            else {
+                patternProperties += `let evaluated = false\n`;
+            }
+        }
+        for (const key in objectSchema.patternProperties) {
+            patternProperties +=
+                "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
+            if (additionalProperties) {
+                patternProperties += "evaluated = true\n";
+            }
+            patternProperties +=
+                "const result = " +
+                    parsedPatternProperties[key] +
+                    ".safeParse(value[key])\n";
+            patternProperties += "if (!result.success) {\n";
+            patternProperties += `ctx.addIssue({
+          path: [key],
+          code: 'custom',
+          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
+          params: {
+            issues: result.error.issues
+          }
+        })\n`;
+            patternProperties += "}\n";
+            patternProperties += "}\n";
+        }
+        if (additionalProperties) {
+            patternProperties += "if (!evaluated) {\n";
+            patternProperties +=
+                "const result = " + additionalProperties + ".safeParse(value[key])\n";
+            patternProperties += "if (!result.success) {\n";
+            patternProperties += `ctx.addIssue({
+          path: [key],
+          code: 'custom',
+          message: \`Invalid input: must match catchall schema\`,
+          params: {
+            issues: result.error.issues
+          }
+        })\n`;
+            patternProperties += "}\n";
+            patternProperties += "}\n";
+        }
+        patternProperties += "}\n";
+        patternProperties += "})";
+        // Store original patternProperties in meta for JSON Schema round-trip
+        if (refs.preserveJsonSchemaForRoundTrip) {
+            const patternPropsJson = JSON.stringify(Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([pattern, schema]) => [
+                pattern,
+                schema
+            ])));
+            patternProperties += `.meta({ __jsonSchema: { patternProperties: ${patternPropsJson} } })`;
+        }
+    }
+    // Check if there will be an .and() call that adds properties from oneOf/anyOf/allOf
+    // 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 = parseSchema_js_1.its.an.anyOf(objectSchema) || parseSchema_js_1.its.a.oneOf(objectSchema) || parseSchema_js_1.its.an.allOf(objectSchema);
+    let output = properties
+        ? patternProperties
+            ? properties + patternProperties
+            : additionalProperties
+                ? additionalProperties === "z.never()"
+                    // Don't use .strict() if there are composition keywords that add properties
+                    ? hasCompositionKeywords
+                        ? properties
+                        : properties + ".strict()"
+                    : properties + `.catchall(${additionalProperties})`
+                : properties
+        : patternProperties
+            ? patternProperties
+            : additionalProperties
+                ? `z.record(z.string(), ${additionalProperties})`
+                : `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 = (0, parseSchema_js_1.parseSchema)(unevaluated, {
+            ...refs,
+            path: [...refs.path, "unevaluatedProperties"],
+        });
+        const knownKeys = objectSchema.properties ? Object.keys(objectSchema.properties) : [];
+        const patterns = objectSchema.patternProperties
+            ? Object.keys(objectSchema.patternProperties).map((p) => new RegExp(p))
+            : [];
+        output += `.superRefine((value, ctx) => {
+  for (const key in value) {
+    const isKnown = ${JSON.stringify(knownKeys)}.includes(key);
+    const matchesPattern = ${patterns.length ? "[" + patterns.map((r) => r.toString()).join(",") + "]" : "[]"}.some((r) => r.test(key));
+    if (!isKnown && !matchesPattern) {
+      const result = ${unevaluatedSchema}.safeParse(value[key]);
+      if (!result.success) {
+        ctx.addIssue({ code: "custom", path: [key], message: "Invalid unevaluated property", params: { issues: result.error.issues } });
+      }
+    }
+  }
+})`;
+    }
+    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 &&
+                (x.properties || x.additionalProperties || x.patternProperties)
+                ? { ...x, type: "object" }
+                : x),
+        }, refs)})`;
+    }
+    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 &&
+                (x.properties || x.additionalProperties || x.patternProperties)
+                ? { ...x, type: "object" }
+                : x),
+        }, refs)})`;
+    }
+    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 &&
+                (x.properties || x.additionalProperties || x.patternProperties)
+                ? { ...x, type: "object" }
+                : x),
+        }, refs)})`;
+    }
+    // Handle if/then/else conditionals on object schemas
+    if (parseSchema_js_1.its.a.conditional(objectSchema)) {
+        output += `.and(${(0, parseIfThenElse_js_1.parseIfThenElse)(objectSchema, refs)})`;
+    }
+    // propertyNames
+    if (objectSchema.propertyNames) {
+        const normalizedPropNames = typeof objectSchema.propertyNames === "object" &&
+            !objectSchema.propertyNames.type &&
+            objectSchema.propertyNames.pattern
+            ? { ...objectSchema.propertyNames, type: "string" }
+            : objectSchema.propertyNames;
+        const propNameSchema = (0, parseSchema_js_1.parseSchema)(normalizedPropNames, {
+            ...refs,
+            path: [...refs.path, "propertyNames"],
+        });
+        output += `.superRefine((value, ctx) => {
+  for (const key in value) {
+    const result = ${propNameSchema}.safeParse(key);
+    if (!result.success) {
+      ctx.addIssue({
+        path: [key],
+        code: "custom",
+        message: "Invalid property name",
+        params: { issues: result.error.issues }
+      });
+    }
+  }
+})`;
+    }
+    // dependentSchemas
+    if (objectSchema.dependentSchemas && typeof objectSchema.dependentSchemas === "object") {
+        const entries = Object.entries(objectSchema.dependentSchemas);
+        if (entries.length) {
+            output += `.superRefine((obj, ctx) => {
+  ${entries
+                .map(([key, schema], idx) => {
+                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) {
+      ctx.addIssue({ code: "custom", message: "Dependent schema failed", path: [], params: { issues: result.error.issues } });
+    }
+  }`;
+            })
+                .join("\n  ")}
+})`;
+        }
+    }
+    return output;
+}
+const shouldUseGetter = (parsed, refs) => {
+    if (!parsed)
+        return false;
+    if (refs.currentSchemaName && parsed.includes(refs.currentSchemaName)) {
+        return true;
+    }
+    return Boolean(refs.inProgress && refs.inProgress.has(parsed));
+};

package/dist/cjs/parsers/parseOneOf.js

@@ -0,0 +1,53 @@
+"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 (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+    }
+    if (schema.oneOf.length === 1) {
+        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) => (0, parseSchema_js_1.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(", ")}])`;
+};
+exports.parseOneOf = parseOneOf;