cannot figure out how to create a schema from the discriminator key of a discriminated union

[laser]

Howdy, all. First off, thanks for the amazing library. We really enjoy using it here at the office.

Context: We'd like to create a Zod schema that represents the set of values used as discriminator keys in a discriminated union.

Given this code:

const Result = z.discriminatedUnion("status", [
  z.object({ status: z.literal("success"), data: z.string() }),
  z.object({ status: z.literal("failed"), error: z.instanceof(Error) }),
]);

type Result = z.infer<typeof Result>;

We'd like to produce a new schema:

const ResultStatus = Result.shape.type // does not compile

type ResultStatus = z.infer<typeof ResultStatus>;

There is no shape property on the thing returned from a call to z.discriminatedUnion. I surely must be doing this wrong.

Thanks in advance!

[Panth977]

maybe this will solve the query @laser

const SuccessResult = z.object({ status: z.literal('success'), data: z.string() });
const FailedResult = z.object({ status: z.literal('failed'), error: z.instanceof(Error) });
const Result = z.discriminatedUnion('status', [SuccessResult, FailedResult]);
type SuccessResult = z.infer<typeof SuccessResult>;
type FailedResult = z.infer<typeof FailedResult>;
type Result = z.infer<typeof Result>;
const discriminator = Result.discriminator; // const discriminator: "status"
const options = Result.options; // const options: [SuccessResult, FailedResult]
const optionsMap = Result.optionsMap; // const optionsMap: Map{'success' => SuccessResult, 'failed' => FailedResult}

[laser]

Hi @Panth977. Thanks for the response. Unfortunately (for me), this isn't what I'm trying to achieve.

Here's a better example of what I'd like to accomplish (note the ???)

const Result = z.discriminatedUnion("status", [
  z.object({ status: z.literal("success"), data: z.string() }),
  z.object({ status: z.literal("failed"), error: z.instanceof(Error) }),
]);

type Result = z.infer<typeof Result>;

const ResultStatus = ??? // what goes here?

type ResultStatus = z.infer<typeof ResultStatus>;

function printStatus(x: ResultStatus) {
  console.log(x);
}

printStatus("success"); // ok
printStatus("flarp"); // I'd like this to be rejected by the type checker

Again, I'd like to create a schema (ResultStatus) which is derived from Result, and which is functionally identical to:

z.union([z.literal("success"), z.literal("failed")]);

[laser]

I also tried this:

type ExtractStatus<T> = T extends { status: infer S } ? S : never;

type ResultStatus = ExtractStatus<Result>;

export const ResultStatus: toZod<ResultStatus> = z.union([
  z.literal('success'),
  z.literal('failed')
]);

...but that does not compile:

error TS2322: Type 'ZodUnion<[ZodLiteral<"success">, ZodLiteral<"failed">]>' is not assignable to type 'never'.

15 export const ResultStatus: toZod<ResultStatus> = z.union([z.literal('success'), z.literal('failed')]);
                ~~~~~~~~~~~~


Found 1 error in src/types/foo.ts:15


Process finished with exit code 2

[Panth977]

Alright @laser , in that case you can do

type Result = z.infer<typeof Result>;
type discriminator = typeof Result.discriminator;
type options = typeof Result.options;
type ResultStatusSchema = options[number] extends z.ZodObject<{ [key in discriminator]: infer T } & z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny>
    ? T
    : never;
type ResultStatus = z.infer<ResultStatusSchema>;

function printStatus(x: ResultStatus) {
    console.log(x);
}

printStatus('success'); // ok
printStatus('flarp'); // I'd like this to be rejected by the type checker

[Panth977]

you can also calculate ResultStatusSchema it following way

type ResultStatusSchema = options[number]['shape'][discriminator];

[laser]

@Panth977 - Thanks for your answer.

I have no trouble creating a type which represents the union of strings used as the discriminator key for Result. This can be achieved using a few of the approaches described above (type ResultStatus = ExtractStatus<Result>; or type ResultStatusSchema = options[number]['shape'][discriminator];).

I have not been able to determine, however, how to create a Zod schema that represents the union of strings used as the discriminator key for Result.

I'll expand my code snippet to better explain what I mean:

const ResultSchema = z.discriminatedUnion("status", [
  z.object({ status: z.literal("success"), data: z.string() }),
  z.object({ status: z.literal("failed"), error: z.instanceof(Error) }),
]);

type ResultType = z.infer<typeof ResultSchema>;

const ResultStatusSchema = ??? // what goes here?

type ResultStatusType = z.infer<typeof ResultStatusSchema>;

function printStatus(x: ResultStatusType) {
  console.log(x);
}

printStatus("success"); // ok
printStatus("flarp"); // I'd like this to be rejected by the type checker

const x: ResultStatusType = ResultStatusSchema.parse("sucess"); // ok
const y: ResultStatusType = ResultStatusSchema.parse("flarp"); // I'd like this to throw a runtime error due to parse failure

[JacobWeisenburger]

Is this what you are looking for?

const ResultStatusSchema = z.enum( [ 'success', 'failed' ] )
type ResultStatusType = z.infer<typeof ResultStatusSchema>
// type ResultStatusType = 'success' | 'failed'

const ResultSchema = z.discriminatedUnion( 'status', [
    z.object( { status: ResultStatusSchema.extract( [ 'success' ] ), data: z.string() } ),
    z.object( { status: ResultStatusSchema.extract( [ 'failed' ] ), error: z.instanceof( Error ) } ),
] )
type ResultType = z.infer<typeof ResultSchema>
// type ResultType = {
//     status: 'success'
//     data: string
// } | {
//     status: 'failed'
//     error: Error
// }

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[laser]

@JacobWeisenburger - Yep, that's it. Thanks! I sent a little SponsorCoin your way. I would have never thought that using enum instead of union would have made any a difference.

The value created with z.union([z.literal("success"), z.literal("failed")]) does not have an extract method, but the value produced by z.enum([ 'success', 'failed' ]) does.

Two 'lil baby questions for you, since I've got your attention:

1. It looks to me like the types which I can infer (via z.infer) from both the enum and union-created types are identical. Do you know why it would be the case that there is no extract method on the schema created with union?
2. I don't see the extract method in the Zod documentation. How'd you know about this method? Reading source code?

[JacobWeisenburger]

Thanks so much for the sponsorship!

---

1. It looks to me like the types which I can infer (via z.infer) from both the enum and union-created types are identical. Do you know why it would be the case that there is no extract method on the schema created with union?

z.union is far more generalized, so it might be really hard to implement. I'm only guessing cuz I'm not the author of zod.

---

2. I don't see the extract method in the Zod documentation. How'd you know about this method? Reading source code?

I can't remember who it was, but someone else suggested it to me a long time ago. If they hadn't, I probably wouldn't know about it either.

[laser]

Word, makes sense. Thanks again for helping me out.

[JacobWeisenburger]

No problem. Feel free to mention me on any future questions, and I'll try my best to answer quickly.

[Panth977]

@laser
it seems like you have to write lot more, if there is no use or purpose of enum, then you can do

const ResultStatusSchema = z.union([
    z.never(), 
    z.never(), 
    ...ResultSchema.options.map(x => x.shape[ResultSchema.discriminator])
]);

[iOSonntag]

Damn i wished this have been in the docs, I searched for it ages thanks @JacobWeisenburger

[tommysullivan]

awesome, now if only

const ResultStatusSchema = z.union([
    z.never(), 
    z.never(), 
    ...ResultSchema.options.map(x => x.shape[ResultSchema.discriminator])
]);

could be encapsulated into a typesafe function that accepts any discriminated union schema and does the needful. i did a quick attempt but it ends up with string[] and any in the resultant type.

[tommysullivan]

i hacked something that seems to work and gives typesafety but could not condense it into a single function, there is some type information loss that seems to prevent it:

zodDiscriminators.ts

import { z, ZodDiscriminatedUnion } from "zod";

type ExtractedDiscriminators<T, D extends string> = T extends { [d in D]: infer S } ? S : never;

export const zodDiscriminators = <T extends ZodDiscriminatedUnion<any, any>>(schema:T):readonly ExtractedDiscriminators<z.infer<T>, T["discriminator"]>[] => schema.options.map(
    (x) => x.shape[schema.discriminator]
) as any as readonly ExtractedDiscriminators<z.infer<T>, T["discriminator"]>[]

zodUnionOfLiterals.ts

import { z } from "zod";

export function zodUnionOfLiterals<T extends string | number> ( zodDiscriminators: readonly T[] ) {
    const literals = zodDiscriminators.map(
        x => z.literal( x )
    ) as unknown as readonly [ z.ZodLiteral<T>, z.ZodLiteral<T>, ...z.ZodLiteral<T>[] ]
    return z.union( literals )
}

test.ts (works but need to call 2 functions with a concretion)

import { z } from "zod";
import { PlayerCard } from "../../castleRisk/cards/PlayerCard";
import { zodDiscriminators } from "./zodDiscriminators";
import { zodUnionOfLiterals } from "./zodUnionOfLiterals";

const playerCardDiscriminators = zodDiscriminators(PlayerCard)
//typehint: const playerCardDiscriminators: readonly ("Diplomat" | "Spy" | "General" | "Marshall" | "Admiral" | "Reinforcements")[]

const CardType = zodUnionOfLiterals(playerCardDiscriminators);
//seems a valid union zod schema

type CardType = z.infer<typeof CardType>;
//typehint: type CardType = "Diplomat" | "Spy" | "General" | "Marshall" | "Admiral" | "Reinforcements"

where PlayerCard here is a normal zod discriminated union discriminated by the strings shown in the comments above in key URI

unified.ts (does not work)

import { z, ZodDiscriminatedUnion, ZodDiscriminatedUnionOption } from "zod";
import { PlayerCard } from "../../castleRisk/cards/PlayerCard";
import { zodDiscriminators } from "./zodDiscriminators";
import { zodUnionOfLiterals } from "./zodUnionOfLiterals";

const unified = <
  Discriminator extends string,
  Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[],
  T extends ZodDiscriminatedUnion<Discriminator, Options>
>(
  schema: T
) => {
  const discriminators = zodDiscriminators(schema);

  //compile error on discriminators: Type 'unknown' is not assignable to type 'string | number'
  return zodUnionOfLiterals(discriminators);
};

//cannot call due to compile error with unified function
const CardType = unified(PlayerCard);
type CardType = z.infer<typeof CardType>;

[tommysullivan]

when i tried to make a single generic function whose body was literally zodUnionOfLiterals(zodDiscriminators(input)) with the matching signatures (including the ugly casts) it still yielded error. but if i use a concretion when calling zodDiscriminators (as i do in test.ts above), the result is well typed enough for zodUnionOfLiterals to give a valid schema and z.inferred type

obv i am trying to dry up the original expression in the previously given answer since that would be tedious / hard to remember.