Using union on array containing spreaded arrays

[doteric]

Hello,
I'm trying to use z.union together with multiple arrays that would let's say come from different files.

Below is the example of my code, variable names are just for the purpose of the example.

import { z } from 'zod';

const array1 = [
  z.object({
    type: z.literal('TEST_1'),
  }),
];

const array2 = [
  z.object({
    type: z.literal('SOME_OTHER_ACTION'),
    payload: z.object({
      myNumber: z.number(),
    })
  }),
  z.object({
    type: z.literal('NOTHING'),
    payload: z.object({
      otherNumber: z.number(),
    })
  }),
  z.object({
    type: z.literal('HELLO'),
    payload: z.object({
      firstNumber: z.number(),
      secondNumber: z.number(),
    })
  }),
];

/*
  The below results in error (replaced ZodObject with ...):
  Argument of type '...' is not assignable to parameter of type '[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]'.
  Property '0' is optional in type '...' but required in type '[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]'.ts(2345)
*/
const wsMessagesParser = z.union([
  ...array1,
  ...array2,
]);

I guess this is to force users to provide at least 2 ZodTypeAny.
So for example doing something like this fixes the error mentioned above (or just anything that matches ZodTypeAny):

const wsMessagesParser = z.union([
  z.object({
    type: z.literal('DUMMY_1'),
  }),
  z.object({
    type: z.literal('DUMMY_2'),
  }),
  ...basicActionsPartial,
  ...inGameActionsPartial,
]);

Does anyone maybe have some proper way around this without the need of requiring those 2 dummies?

[JacobWeisenburger]

Try Discriminated unions

[doteric]

Hello @JacobWeisenburger
Sadly I'm still getting an error.

Argument of type '(ZodObject<{ type: ZodLiteral<"GET_SERVER_VERSION">; }, "strip", ZodTypeAny, { type?: "GET_SERVER_VERSION"; }, { type?: "GET_SERVER_VERSION"; }> | ... 15 more ... | ZodObject<...>)[]' is not assignable to parameter of type '[ZodDiscriminatedUnionOption<"type", Primitive>, ZodDiscriminatedUnionOption<"type", Primitive>, ...ZodDiscriminatedUnionOption<...>[]]'.
  Source provides no match for required element at position 0 in target.ts(2345)

Looks like it's having a problem with the spread and thinking that there might be 0 elements? 🤔

[scotttrinh]

Ahh, yeah the inferred type from TypeScript is a regular array of types (which is a super-set of 0-tuples and 1-tuples), but the type of ZodUnion requires that there are more than 1 element. You either need to declare your arrays with a tuple type that guarantees that spreading them includes at least two elements (which is hard since arrays are runtime mutable).

Personally, I would just declare those base arrays as unions themselves, but that doesn't work for your 1-tuple (array1 in your example), but if your normal use-case typically includes arrays of length > 1, you can do that:

import { z } from 'zod';

const array1 = z.union([
  z.object({
    type: z.literal('TEST_1'),
  }),
  z.object({ type: z.literal('TEST_2') }),
]);

const array2 = z.union([
  z.object({
    type: z.literal('SOME_OTHER_ACTION'),
    payload: z.object({
      myNumber: z.number(),
    })
  }),
  z.object({
    type: z.literal('NOTHING'),
    payload: z.object({
      otherNumber: z.number(),
    })
  }),
  z.object({
    type: z.literal('HELLO'),
    payload: z.object({
      firstNumber: z.number(),
      secondNumber: z.number(),
    })
  }),
]);


const wsMessagesParser = z.union([
  array1,
  array2,
]);

I have a few use cases like this (Redux actions kind of have this flavor) but it's not super common in my usage of Zod so far.

[doteric]

Thanks @scotttrinh, it looks like it's working fine. As for arrays of size 1 I can just still use the spread operator, but place them at the bottom of the final union and it works fine.
So simply if the first 2 arrays are used like you mention and both have a length of >=2 then the rest can be a spread operator.