@gabrielbryk/json-schema-to-zod 2.12.1 → 2.14.0

package/dist/parsers/parseArray.js

@@ -2,12 +2,39 @@ import { withMessage } from "../utils/withMessage.js";
 import { parseSchema } from "./parseSchema.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
 export const parseArray = (schema, refs) => {
-    if (Array.isArray(schema.items)) {
+    // JSON Schema 2020-12 uses `prefixItems` for tuples.
+    // Older drafts used `items` as an array.
+    const prefixItems = schema.prefixItems || (Array.isArray(schema.items) ? schema.items : undefined);
+    if (prefixItems) {
         // Tuple case
-        const itemResults = schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }));
-        let tuple = `z.tuple([${itemResults.map(r => r.expression).join(", ")}])`;
-        const tupleTypes = itemResults.map(r => r.type).join(", ");
-        let tupleType = `z.ZodTuple<[${tupleTypes}]>`;
+        const itemResults = prefixItems.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "prefixItems", i] }));
+        let tuple = `z.tuple([${itemResults.map((r) => r.expression).join(", ")}])`;
+        // We construct the type manually for the tuple part
+        let tupleTypes = itemResults.map((r) => r.type).join(", ");
+        let tupleType = `z.ZodTuple<[${tupleTypes}], null>`; // Default null rest
+        // Handle "additionalItems" (older drafts) or "items" (2020-12 when prefixItems is used)
+        // If prefixItems is present, `items` acts as the schema for additional items.
+        // If prefixItems came from `items` (array form), then `additionalItems` controls the rest.
+        const additionalSchema = schema.prefixItems ? schema.items : schema.additionalItems;
+        if (additionalSchema === false) {
+            // Closed tuple
+        }
+        else if (additionalSchema) {
+            const restSchema = additionalSchema === true
+                ? anyOrUnknown(refs)
+                : parseSchema(additionalSchema, {
+                    ...refs,
+                    path: [...refs.path, "items"],
+                });
+            tuple += `.rest(${restSchema.expression})`;
+            tupleType = `z.ZodTuple<[${tupleTypes}], ${restSchema.type}>`;
+        }
+        else {
+            // Open by default
+            const anyRes = anyOrUnknown(refs);
+            tuple += `.rest(${anyRes.expression})`;
+            tupleType = `z.ZodTuple<[${tupleTypes}], ${anyRes.type}>`;
+        }
         if (schema.contains) {
             const containsResult = parseSchema(schema.contains, {
                 ...refs,
@@ -24,18 +51,18 @@ export const parseArray = (schema, refs) => {
     ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
   }
 })`;
-            // In Zod v4, .superRefine() doesn't change the type
         }
         return {
             expression: tuple,
             type: tupleType,
         };
     }
-    // Array case
+    // Regular Array case
+    const itemsSchema = schema.items;
     const anyOrUnknownResult = anyOrUnknown(refs);
-    const itemResult = !schema.items
+    const itemResult = !itemsSchema || itemsSchema === true
         ? anyOrUnknownResult
-        : parseSchema(schema.items, {
+        : parseSchema(itemsSchema, {
             ...refs,
             path: [...refs.path, "items"],
         });
@@ -44,13 +71,13 @@ export const parseArray = (schema, refs) => {
     r += withMessage(schema, "minItems", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
     r += withMessage(schema, "maxItems", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
     if (schema.uniqueItems === true) {
@@ -94,7 +121,6 @@ export const parseArray = (schema, refs) => {
   }
 })`;
     }
-    // In Zod v4, .superRefine() doesn't change the type, so no wrapping needed
     return {
         expression: r,
         type: arrayType,

package/dist/parsers/parseMultipleType.js

@@ -1,8 +1,8 @@
 import { parseSchema } from "./parseSchema.js";
 export const parseMultipleType = (schema, refs) => {
     const schemas = schema.type.map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true }));
-    const expressions = schemas.map(s => s.expression).join(", ");
-    const types = schemas.map(s => s.type).join(", ");
+    const expressions = schemas.map((s) => s.expression).join(", ");
+    const types = schemas.map((s) => s.type).join(", ");
     return {
         expression: `z.union([${expressions}])`,
         type: `z.ZodUnion<[${types}]>`,

package/dist/parsers/parseNumber.js

@@ -1,115 +1,57 @@
 import { withMessage } from "../utils/withMessage.js";
 export const parseNumber = (schema) => {
-    const formatError = schema.errorMessage?.format;
-    const numericFormatMap = {
-        int32: "z.int32",
-        uint32: "z.uint32",
-        float32: "z.float32",
-        float64: "z.float64",
-        safeint: "z.safeint",
-        int64: "z.int64",
-        uint64: "z.uint64",
+    const formatMessage = schema.errorMessage?.format;
+    const formatParams = formatMessage ? `{ message: ${JSON.stringify(formatMessage)} }` : "";
+    const formatMap = {
+        int32: { expression: `z.int32(${formatParams})`, type: "z.ZodNumber" },
+        uint32: { expression: `z.uint32(${formatParams})`, type: "z.ZodNumber" },
+        float32: { expression: `z.float32(${formatParams})`, type: "z.ZodNumber" },
+        float64: { expression: `z.float64(${formatParams})`, type: "z.ZodNumber" },
+        safeint: { expression: `z.safeint(${formatParams})`, type: "z.ZodNumber" },
+        int64: { expression: `z.int64(${formatParams})`, type: "z.ZodBigInt" },
+        uint64: { expression: `z.uint64(${formatParams})`, type: "z.ZodBigInt" },
     };
-    const mappedFormat = schema.format && numericFormatMap[schema.format] ? numericFormatMap[schema.format] : undefined;
-    const formatParams = formatError !== undefined ? `{ error: ${JSON.stringify(formatError)} }` : "";
-    let r = mappedFormat ? `${mappedFormat}(${formatParams})` : "z.number()";
-    if (schema.type === "integer") {
-        if (!mappedFormat) {
-            r += withMessage(schema, "type", () => ({
-                opener: ".int(",
-                closer: ")",
-                messagePrefix: "{ error: ",
-                messageCloser: " })",
-            }));
-        }
+    let r = schema.type === "integer" ? "z.int()" : "z.number()";
+    let zodType = schema.type === "integer" ? "z.ZodInt" : "z.ZodNumber";
+    if (schema.format && formatMap[schema.format]) {
+        const mapped = formatMap[schema.format];
+        r = mapped.expression;
+        zodType = mapped.type;
     }
-    else {
-        if (!mappedFormat) {
-            r += withMessage(schema, "format", ({ value }) => {
-                if (value === "int64") {
-                    return {
-                        opener: ".int(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                }
-            });
-        }
+    r += withMessage(schema, "multipleOf", ({ json }) => ({
+        opener: `.multipleOf(${json}`,
+        closer: ")",
+        messagePrefix: ", { message: ",
+        messageCloser: " })",
+    }));
+    const minimum = schema.minimum;
+    const maximum = schema.maximum;
+    const exclusiveMinimum = schema.exclusiveMinimum;
+    const exclusiveMaximum = schema.exclusiveMaximum;
+    const minMessage = schema.errorMessage?.minimum;
+    const maxMessage = schema.errorMessage?.maximum;
+    const exclMinMessage = schema.errorMessage?.exclusiveMinimum;
+    const exclMaxMessage = schema.errorMessage?.exclusiveMaximum;
+    if (typeof exclusiveMinimum === "number") {
+        r += `.gt(${exclusiveMinimum}${exclMinMessage ? `, { message: ${JSON.stringify(exclMinMessage)} }` : ""})`;
     }
-    r += withMessage(schema, "multipleOf", ({ value, json }) => {
-        if (value === 1) {
-            if (r.startsWith("z.number().int(")) {
-                return;
-            }
-            return {
-                opener: ".int(",
-                closer: ")",
-                messagePrefix: "{ error: ",
-                messageCloser: " })",
-            };
-        }
-        return {
-            opener: `.multipleOf(${json}`,
-            closer: ")",
-            messagePrefix: ", { error: ",
-            messageCloser: " })",
-        };
-    });
-    if (typeof schema.minimum === "number") {
-        if (schema.exclusiveMinimum === true) {
-            r += withMessage(schema, "minimum", ({ json }) => ({
-                opener: `.gt(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
-        else {
-            r += withMessage(schema, "minimum", ({ json }) => ({
-                opener: `.gte(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
+    else if (exclusiveMinimum === true && typeof minimum === "number") {
+        r += `.gt(${minimum}${exclMinMessage ? `, { message: ${JSON.stringify(exclMinMessage)} }` : ""})`;
     }
-    else if (typeof schema.exclusiveMinimum === "number") {
-        r += withMessage(schema, "exclusiveMinimum", ({ json }) => ({
-            opener: `.gt(${json}`,
-            closer: ")",
-            messagePrefix: ", { error: ",
-            messageCloser: " })",
-        }));
+    else if (typeof minimum === "number") {
+        r += `.min(${minimum}${minMessage ? `, { message: ${JSON.stringify(minMessage)} }` : ""})`;
     }
-    if (typeof schema.maximum === "number") {
-        if (schema.exclusiveMaximum === true) {
-            r += withMessage(schema, "maximum", ({ json }) => ({
-                opener: `.lt(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
-        else {
-            r += withMessage(schema, "maximum", ({ json }) => ({
-                opener: `.lte(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
+    if (typeof exclusiveMaximum === "number") {
+        r += `.lt(${exclusiveMaximum}${exclMaxMessage ? `, { message: ${JSON.stringify(exclMaxMessage)} }` : ""})`;
     }
-    else if (typeof schema.exclusiveMaximum === "number") {
-        r += withMessage(schema, "exclusiveMaximum", ({ json }) => ({
-            opener: `.lt(${json}`,
-            closer: ")",
-            messagePrefix: ", { error: ",
-            messageCloser: " })",
-        }));
+    else if (exclusiveMaximum === true && typeof maximum === "number") {
+        r += `.lt(${maximum}${exclMaxMessage ? `, { message: ${JSON.stringify(exclMaxMessage)} }` : ""})`;
+    }
+    else if (typeof maximum === "number") {
+        r += `.max(${maximum}${maxMessage ? `, { message: ${JSON.stringify(maxMessage)} }` : ""})`;
     }
     return {
         expression: r,
-        type: "z.ZodNumber",
+        type: zodType,
     };
 };