Non-exhaustive discriminated union, with template for fallbacks

[tremby]

I have data coming in which includes an array of objects of this (simplified) form:

z.object({
	RequestCode: z.string(),
	Value: z.any(),
})

There are a lot of possible RequestCode strings, and I can discriminate based on them and know the types of Value and the other properties I've omitted. However, I don't know all the possible values, and more could be added at any time. This means I can't make an exhaustive discriminated union. I also don't care about them all anyway.

The ones I care about look like this:

z.object({
	RequestCode: z.literal("type1"),
	Value: z.number(),
})
z.object({
	RequestCode: z.literal("type2"),
	Value: z.string(),
})

I can put these in a union or discriminated union, but I also need to accept all the other types I don't care about.

When I process them I need to narrow the type.

My first attempt was like this:

const myInput = z.array(z.object({
	Symbol: z.string(),
	DataPoints: z.array(z.union([
		z.discriminatedUnion("RequestCode", [
			z.object({
				RequestCode: z.literal("type1"),
				Value: z.number(),
			}),
			z.object({
				RequestCode: z.literal("type2"),
				Value: z.string(),
			}),
		]),
		z.object({
			RequestCode: z.string(),
			Value: z.any(),
		}),
	])),
}));

// ...

for (const entry of parsed) {
	for (const point of entry.DataPoints) {
		switch (point.RequestCode) {
			case "type1":
				// not narrowed correctly
				break;
			case "type2":
				// not narrowed correctly
				break;
			default:
				// generic
				break;
		}
	}
}

But this doesn't narrow like I wanted it to. TS doesn't know for example in the type1 case if it's a type1 or the generic, and so point.Value has type number | string.

Next I tried without Zod, typing RequestCode as Exclude<string, Type1["RequestCode"] | Type2["RequestCode"]>, but this had the same problem.

So at the moment I am using type guards:

const type1 = z.object({
	RequestCode: z.literal("type1"),
	Value: z.number(),
});
const type2 = z.object({
	RequestCode: z.literal("type2"),
	Value: z.string(),
});

function isType1(data: any): data is z.infer<typeof type1> { return type1.safeParse(data).success; }
function isType2(data: any): data is z.infer<typeof type2> { return type2.safeParse(data).success; }

const myInput = z.array(z.object({
	Symbol: z.string(),
	DataPoints: z.array(z.union([
		z.discriminatedUnion("RequestCode", [
			type1,
			type2,
		]),
		z.object({
			RequestCode: z.string(),
			Value: z.any(),
		}),
	])),
}));

// ...

for (const entry of parsed) {
	for (const point of entry.DataPoints) {
		if (isType1(point)) {
			// narrowed correctly
		} else if (isType2(point)) {
			// narrowed correctly
		} else {
			// generic
		}
	}
}

This works but I'm going to have dozens of these types and it's a lot of boilerplate.

1. Any suggestions on a better way to do this?

2. If I'm on the right track already with the type guards, is there at least a way to reduce the amount of boilerplate?

   Like if I declare all the data point types as properties of an object ({ type1: z.object(...), type2: z.object(...), ... }) is there maybe a terse way to generate all the type guards via a map from that in a way that TS understands their types, and then beyond that to feed them all to Zod for the union? I don't want to have to add code in 3 places every time I need to handle another of these data types.

[kylewlacy]

I'd love to see this in Zod proper, but in the meantime, I came up with a small utility for this:

import { z } from "zod";

type Primitive = string | number | symbol | bigint | boolean | null | undefined;
function isPrimitive(v: unknown): v is Primitive {
  return typeof v === "string" || typeof v === "number" || typeof v === "symbol" || typeof v === "bigint" || typeof v === "boolean" || v == null;
};

export function orFallback<T extends z.ZodDiscriminatedUnion<string, any>, U>(
  union: T,
  fallback: (value: Record<string, unknown>) => U
): z.ZodType<z.output<T> | U, z.ZodTypeDef, Record<string, unknown>> {
  const inOptionsMap = (k: unknown) => isPrimitive(k) && union.optionsMap.has(k);

  return z.record(z.unknown()).transform((value, ctx) => {
    if (
      union.discriminator in value &&
      inOptionsMap(value[union.discriminator])
    ) {
      const result = union.safeParse(value);
      if (result.success) {
        return result.data;
      } else {
        for (const issue of result.error.issues) {
          ctx.addIssue(issue);
        }
      }
    } else {
      return fallback(value);
    }
  });
}

Here's what usage looks like:

// The raw discriminated union we want to parse
const ThingStrict = z.discriminatedUnion("type", [
  z.object({ type: z.literal("foo"), foo: z.string() }),
  z.object({ type: z.literal("bar"), bar: z.number() }),
  z.object({ type: z.literal("baz"), baz: z.boolean() }),
]);

// Our union that returns a fallback if no discriminant matches
const Thing = orFallback(ThingStrict, (value) => ({ type: "unknown", value } as const));

// Parsing examples:

Thing.parse({ type: "foo", foo: "abc" });
// Valid discriminant, parses like normal
// { type: "foo", foo: "abc" }

Thing.parse({ type: "asdf" });
// Unknown discriminant, parses to the fallback
// { type: "unknown", value: { type: "asdf" } }

Thing.safeParse({ type: "foo", foo: 123 });
// Valid discriminant, but the option does not parse properly
// { success: false, error: {errors: [{message: "Expected string, received number"}]}}