fix(JSONSchema): add type for enum (#4577)

* fix(JSONSchema): add type for enum

* Tweak

---------

Co-authored-by: Colin McDonnell <[email protected]>

Author: imranbarbhuiya

packages/zod/src/v4/classic/tests/to-json-schema.test.ts

@@ -639,15 +639,35 @@ describe("toJSONSchema", () => {
 
   // enum
   test("enum", () => {
-    const schema = z.enum(["a", "b", "c"]);
-    expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+    const a = z.enum(["a", "b", "c"]);
+    expect(z.toJSONSchema(a)).toMatchInlineSnapshot(`
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "enum": [
           "a",
           "b",
           "c",
         ],
+        "type": "string",
+      }
+    `);
+
+    enum B {
+      A = 0,
+      B = 1,
+      C = 2,
+    }
+
+    const b = z.enum(B);
+    expect(z.toJSONSchema(b)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "enum": [
+          0,
+          1,
+          2,
+        ],
+        "type": "number",
       }
     `);
   });

packages/zod/src/v4/core/schemas.ts

@@ -2636,10 +2636,7 @@ export interface $ZodEnum<T extends util.EnumLike = util.EnumLike> extends $ZodT
 export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constructor("$ZodEnum", (inst, def) => {
   $ZodType.init(inst, def);
 
-  const numericValues = Object.values(def.entries).filter((v) => typeof v === "number");
-  const values = Object.entries(def.entries)
-    .filter(([k, _]) => numericValues.indexOf(+k) === -1)
-    .map(([_, v]) => v);
+  const values = util.getEnumValues(def.entries);
 
   inst._zod.values = new Set<util.Primitive>(values);
 

packages/zod/src/v4/core/to-json-schema.ts

@@ -2,6 +2,7 @@ import type * as checks from "./checks.js";
 import type * as JSONSchema from "./json-schema.js";
 import { $ZodRegistry, globalRegistry } from "./registries.js";
 import type * as schemas from "./schemas.js";
+import { getEnumValues } from "./util.js";
 
 interface JSONSchemaGeneratorParams {
   /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
@@ -400,7 +401,11 @@ export class JSONSchemaGenerator {
         }
         case "enum": {
           const json: JSONSchema.BaseSchema = _json as any;
-          json.enum = Object.values(def.entries);
+          const values = getEnumValues(def.entries);
+          // Number enums can have both string and number values
+          if (values.every((v) => typeof v === "number")) json.type = "number";
+          if (values.every((v) => typeof v === "string")) json.type = "string";
+          json.enum = values;
           break;
         }
         case "literal": {

packages/zod/src/v4/core/util.ts

@@ -203,13 +203,12 @@ export function assertNever(_x: never): never {
 }
 export function assert<T>(_: any): asserts _ is T {}
 
-export function getValidEnumValues(obj: any): any {
-  const validKeys = Object.keys(obj).filter((k: any) => typeof obj[obj[k]] !== "number");
-  const filtered: any = {};
-  for (const k of validKeys) {
-    filtered[k] = obj[k];
-  }
-  return Object.values(filtered);
+export function getEnumValues(entries: EnumLike): EnumValue[] {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values = Object.entries(entries)
+    .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+    .map(([_, v]) => v);
+  return values;
 }
 
 export function joinValues<T extends Primitive[]>(array: T, separator = "|"): string {