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

package/dist/esm/parsers/parseDefault.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDefault = void 0;
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseDefault = (_schema, refs) => {
-    return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseDefault = (_schema, refs) => {
+    return anyOrUnknown(refs);
 };
-exports.parseDefault = parseDefault;

package/dist/esm/parsers/parseEnum.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEnum = void 0;
-const parseEnum = (schema) => {
+export const parseEnum = (schema) => {
     if (schema.enum.length === 0) {
         return "z.never()";
     }
@@ -18,4 +15,3 @@ const parseEnum = (schema) => {
             .join(", ")}])`;
     }
 };
-exports.parseEnum = parseEnum;

package/dist/esm/parsers/parseIfThenElse.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIfThenElse = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseIfThenElse = (schema, refs) => {
-    const $if = (0, parseSchema_js_1.parseSchema)(schema.if, { ...refs, path: [...refs.path, "if"] });
-    const $then = (0, parseSchema_js_1.parseSchema)(schema.then, {
+import { parseSchema } from "./parseSchema.js";
+export const parseIfThenElse = (schema, refs) => {
+    const $if = parseSchema(schema.if, { ...refs, path: [...refs.path, "if"] });
+    const $then = parseSchema(schema.then, {
         ...refs,
         path: [...refs.path, "then"],
     });
-    const $else = (0, parseSchema_js_1.parseSchema)(schema.else, {
+    const $else = parseSchema(schema.else, {
         ...refs,
         path: [...refs.path, "else"],
     });
@@ -32,4 +29,3 @@ const parseIfThenElse = (schema, refs) => {
     }
     return result;
 };
-exports.parseIfThenElse = parseIfThenElse;

package/dist/esm/parsers/parseMultipleType.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMultipleType = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseMultipleType = (schema, refs) => {
+import { parseSchema } from "./parseSchema.js";
+export const parseMultipleType = (schema, refs) => {
     return `z.union([${schema.type
-        .map((type) => (0, parseSchema_js_1.parseSchema)({ ...schema, type }, { ...refs, withoutDefaults: true }))
+        .map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true }))
         .join(", ")}])`;
 };
-exports.parseMultipleType = parseMultipleType;

package/dist/esm/parsers/parseNot.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNot = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseNot = (schema, refs) => {
-    return `${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)}.refine((value) => !${(0, parseSchema_js_1.parseSchema)(schema.not, {
+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")`;
 };
-exports.parseNot = parseNot;

package/dist/esm/parsers/parseNull.js

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

package/dist/esm/parsers/parseNullable.js

@@ -1,12 +1,8 @@
-"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");
+import { omit } from "../utils/omit.js";
+import { parseSchema } from "./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()`;
+export const parseNullable = (schema, refs) => {
+    return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
 };
-exports.parseNullable = parseNullable;

package/dist/esm/parsers/parseNumber.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNumber = void 0;
-const withMessage_js_1 = require("../utils/withMessage.js");
-const parseNumber = (schema) => {
+import { withMessage } from "../utils/withMessage.js";
+export const parseNumber = (schema) => {
     const formatError = schema.errorMessage?.format;
     const numericFormatMap = {
         int32: "z.int32",
@@ -18,7 +15,7 @@ const parseNumber = (schema) => {
     let r = mappedFormat ? `${mappedFormat}(${formatParams})` : "z.number()";
     if (schema.type === "integer") {
         if (!mappedFormat) {
-            r += (0, withMessage_js_1.withMessage)(schema, "type", () => ({
+            r += withMessage(schema, "type", () => ({
                 opener: ".int(",
                 closer: ")",
                 messagePrefix: "{ error: ",
@@ -28,7 +25,7 @@ const parseNumber = (schema) => {
     }
     else {
         if (!mappedFormat) {
-            r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+            r += withMessage(schema, "format", ({ value }) => {
                 if (value === "int64") {
                     return {
                         opener: ".int(",
@@ -40,7 +37,7 @@ const parseNumber = (schema) => {
             });
         }
     }
-    r += (0, withMessage_js_1.withMessage)(schema, "multipleOf", ({ value, json }) => {
+    r += withMessage(schema, "multipleOf", ({ value, json }) => {
         if (value === 1) {
             if (r.startsWith("z.number().int(")) {
                 return;
@@ -61,7 +58,7 @@ const parseNumber = (schema) => {
     });
     if (typeof schema.minimum === "number") {
         if (schema.exclusiveMinimum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+            r += withMessage(schema, "minimum", ({ json }) => ({
                 opener: `.gt(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -69,7 +66,7 @@ const parseNumber = (schema) => {
             }));
         }
         else {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
+            r += withMessage(schema, "minimum", ({ json }) => ({
                 opener: `.gte(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -78,7 +75,7 @@ const parseNumber = (schema) => {
         }
     }
     else if (typeof schema.exclusiveMinimum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => ({
+        r += withMessage(schema, "exclusiveMinimum", ({ json }) => ({
             opener: `.gt(${json}`,
             closer: ")",
             messagePrefix: ", { error: ",
@@ -87,7 +84,7 @@ const parseNumber = (schema) => {
     }
     if (typeof schema.maximum === "number") {
         if (schema.exclusiveMaximum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+            r += withMessage(schema, "maximum", ({ json }) => ({
                 opener: `.lt(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -95,7 +92,7 @@ const parseNumber = (schema) => {
             }));
         }
         else {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
+            r += withMessage(schema, "maximum", ({ json }) => ({
                 opener: `.lte(${json}`,
                 closer: ")",
                 messagePrefix: ", { error: ",
@@ -104,7 +101,7 @@ const parseNumber = (schema) => {
         }
     }
     else if (typeof schema.exclusiveMaximum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => ({
+        r += withMessage(schema, "exclusiveMaximum", ({ json }) => ({
             opener: `.lt(${json}`,
             closer: ")",
             messagePrefix: ", { error: ",
@@ -113,4 +110,3 @@ const parseNumber = (schema) => {
     }
     return r;
 };
-exports.parseNumber = parseNumber;

package/dist/esm/parsers/parseObject.js

@@ -1,14 +1,11 @@
-"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) {
+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) {
     let properties = undefined;
     if (objectSchema.properties) {
         if (!Object.keys(objectSchema.properties).length) {
@@ -19,7 +16,7 @@ function parseObject(objectSchema, refs) {
             properties += Object.keys(objectSchema.properties)
                 .map((key) => {
                 const propSchema = objectSchema.properties[key];
-                const parsedProp = (0, parseSchema_js_1.parseSchema)(propSchema, {
+                const parsedProp = parseSchema(propSchema, {
                     ...refs,
                     path: [...refs.path, "properties", key],
                 });
@@ -35,7 +32,7 @@ function parseObject(objectSchema, 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);
+                    result = addJsdocs(propSchema, result);
                 }
                 return result;
             })
@@ -44,7 +41,7 @@ function parseObject(objectSchema, refs) {
         }
     }
     const additionalProperties = objectSchema.additionalProperties !== undefined
-        ? (0, parseSchema_js_1.parseSchema)(objectSchema.additionalProperties, {
+        ? parseSchema(objectSchema.additionalProperties, {
             ...refs,
             path: [...refs.path, "additionalProperties"],
         })
@@ -55,7 +52,7 @@ function parseObject(objectSchema, refs) {
         const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
             return [
                 key,
-                (0, parseSchema_js_1.parseSchema)(value, {
+                parseSchema(value, {
                     ...refs,
                     path: [...refs.path, "patternProperties", key],
                 }),
@@ -154,7 +151,7 @@ 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 = 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);
+    const hasCompositionKeywords = its.an.anyOf(objectSchema) || its.a.oneOf(objectSchema) || its.an.allOf(objectSchema) || its.a.conditional(objectSchema);
     let output = properties
         ? patternProperties
             ? properties + patternProperties
@@ -170,12 +167,12 @@ function parseObject(objectSchema, refs) {
             ? patternProperties
             : additionalProperties
                 ? `z.record(z.string(), ${additionalProperties})`
-                : `z.record(z.string(), ${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`;
+                : `z.record(z.string(), ${anyOrUnknown(refs)})`;
     if (unevaluated === false && properties && !hasCompositionKeywords) {
         output += ".strict()";
     }
     else if (unevaluated && typeof unevaluated !== 'boolean') {
-        const unevaluatedSchema = (0, parseSchema_js_1.parseSchema)(unevaluated, {
+        const unevaluatedSchema = parseSchema(unevaluated, {
             ...refs,
             path: [...refs.path, "unevaluatedProperties"],
         });
@@ -196,8 +193,8 @@ function parseObject(objectSchema, refs) {
   }
 })`;
     }
-    if (parseSchema_js_1.its.an.anyOf(objectSchema)) {
-        output += `.and(${(0, parseAnyOf_js_1.parseAnyOf)({
+    if (its.an.anyOf(objectSchema)) {
+        output += `.and(${parseAnyOf({
             ...objectSchema,
             anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
                 !x.type &&
@@ -206,8 +203,8 @@ function parseObject(objectSchema, refs) {
                 : x),
         }, refs)})`;
     }
-    if (parseSchema_js_1.its.a.oneOf(objectSchema)) {
-        output += `.and(${(0, parseOneOf_js_1.parseOneOf)({
+    if (its.a.oneOf(objectSchema)) {
+        output += `.and(${parseOneOf({
             ...objectSchema,
             oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
                 !x.type &&
@@ -216,8 +213,8 @@ function parseObject(objectSchema, refs) {
                 : x),
         }, refs)})`;
     }
-    if (parseSchema_js_1.its.an.allOf(objectSchema)) {
-        output += `.and(${(0, parseAllOf_js_1.parseAllOf)({
+    if (its.an.allOf(objectSchema)) {
+        output += `.and(${parseAllOf({
             ...objectSchema,
             allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
                 !x.type &&
@@ -227,8 +224,8 @@ function parseObject(objectSchema, refs) {
         }, 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)})`;
+    if (its.a.conditional(objectSchema)) {
+        output += `.and(${parseIfThenElse(objectSchema, refs)})`;
     }
     // propertyNames
     if (objectSchema.propertyNames) {
@@ -237,7 +234,7 @@ function parseObject(objectSchema, refs) {
             objectSchema.propertyNames.pattern
             ? { ...objectSchema.propertyNames, type: "string" }
             : objectSchema.propertyNames;
-        const propNameSchema = (0, parseSchema_js_1.parseSchema)(normalizedPropNames, {
+        const propNameSchema = parseSchema(normalizedPropNames, {
             ...refs,
             path: [...refs.path, "propertyNames"],
         });
@@ -262,7 +259,7 @@ function parseObject(objectSchema, refs) {
             output += `.superRefine((obj, ctx) => {
   ${entries
                 .map(([key, schema], idx) => {
-                const parsed = (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "dependentSchemas", key] });
+                const parsed = 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) {

package/dist/esm/parsers/parseOneOf.js

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