enum type inference loses refinement

[alpha0010]

Using a zod enum in an object degenerates to generic string.

const MyEnumType = z.enum(['a', 'b']);
type MyEnum = z.infer<typeof MyEnumType>;
type MyObject = {foo: MyEnum};

function testFunc() {
  let x: MyObject = {foo: 'a'};
  const parsed = MyEnumType.safeParse('a');
  if (parsed.success) {
    let y = {foo: parsed.data};
    x = y; // Type '{ foo: string; }' is not assignable to type 'MyObject'.
  }
}

As a workaround, I can use z.union([z.literal('a'), z.literal('b')]), but the verbosity is inconvenient.

[colinhacks]

Seems to be a weird quirk of TypeScript, not a Zod bug. Try this as a workaround:

const y = { foo: parsed.data } as const;

[alpha0010]

Thanks, I will try that. In case it is useful for the future, the io-ts way seems to work.

import * as t from 'io-ts';

const MyEnumType = t.keyof({a: null, b: null});
type MyEnum = t.TypeOf<typeof MyEnumType>;
type MyObject = {foo: MyEnum};

function testFunc() {
  let x: MyObject = {foo: 'a'};
  const data: unknown = 'a';
  if (MyEnumType.is(data)) {
    let y = {foo: data};
    x = y; // Works.
  }
}

[alpha0010]

Potentially related microsoft/TypeScript#36579.