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

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,
     };
 };