Create a z.tuple by mapping over an array

[noahtigner]

I am trying to create a schema for an exhaustive list of objects for each item in an array. I have found a few ways that work, but my "ideal" solution is not working. Any tips?

const PREFERRED_CONTENT_TYPES = ['blogs', 'communityEvents', 'podcasts'] as const;

// helper to generate schemas
const prefSchema = <T extends z.ZodLiteral<unknown>>(
	literal: T
): z.ZodObject<{ name: T; value: z.ZodBoolean }> =>
	z.object({
		name: literal,
		value: z.boolean(),
	});

// method 1: works, but repetitive
const preferredContentSchema = z.tuple([
	prefSchema(z.literal('blogs')),
	prefSchema(z.literal('communityEvents')),
	prefSchema(z.literal('podcasts')),
]);
type PreferredContent = z.infer<typeof preferredContentSchema>;

// method 2: works, but type could be better
const preferredContentSchema = z.array(
	z.object({
		name: z.enum(PREFERRED_CONTENT_TYPES),
		value: z.boolean(),
	})
);
type PreferredContent = z.infer<typeof preferredContentSchema>;

// method 3: ideal, but does not work
const preferredContentSchema = z.tuple(
	PREFERRED_CONTENT_TYPES.map((type) => prefSchema(z.literal(type)))
);

method 1's inferred type

type PreferredContent = [{
    value: boolean;
    name: "blogs";
}, {
    value: boolean;
    name: "communityEvents";
}, {
    value: boolean;
    name: "podcasts";
}]

method 2's inferred type

type PreferredContent = {
    value: boolean;
    name:  "blogs" | "communityEvents" | "podcasts";
}[]

method 3's error

Argument of type 'ZodObject<{ name: ZodLiteral<"blogs" | "communityEvents" | "podcasts">; value: ZodBoolean; }, UnknownKeysParam, ZodTypeAny, { ...; }, { ...; }>[]' is not assignable to parameter of type '[] | [ZodTypeAny, ...ZodTypeAny[]]'.
  Type 'ZodObject<{ name: ZodLiteral<"blogs" | "communityEvents" | "podcasts">; value: ZodBoolean; }, UnknownKeysParam, ZodTypeAny, { ...; }, { ...; }>[]' is not assignable to type '[ZodTypeAny, ...ZodTypeAny[]]'.
    Source provides no match for required element at position 0 in target.

[vajajak]

Have you found a solution to this?

[rijenkii]

Solution 3 can be implemented using some TS casts:

type _Map<T extends readonly unknown[]> = {
  -readonly [K in keyof T]: ReturnType<typeof prefSchema<z.ZodLiteral<T[K]>>>;
};

const preferredContentSchema = z.tuple(
  PREFERRED_CONTENT_TYPES.map((type) =>
    prefSchema(z.literal(type)),
  ) as unknown as _Map<typeof PREFERRED_CONTENT_TYPES>,
);

See playground.

Builtin types for Array.map do not preserve the shape of tuples, so you need casts. See microsoft/TypeScript#29841 for TS issue.