Need Help with recursive Union Type

[Charismara]

Hey there,

i got the following types:

Click to show

type StringTypedFieldExtras = {
  type: "string"
  matches?: RegExp
  minLength?: number
  maxLength?: number
}

type NumberTypedFieldExtras = {
  type: "number"
  min?: number
  max?: number
}

type BooleanTypedFieldExtras = {
  type: "boolean"
}

type DateTypedFieldExtras = {
  type: "date"
  from?: Date
  to?: Date
  format?: string
}

type EnumTypedFieldExtras = {
  type: "enum"
  values: string[]
  valueFormatter?: (value: string) => string
}

type ArrayTypedFieldExtras = {
  type: "array"
  itemType: TypedFieldExtras
  itemLabel: string | ((index: number) => string)
  minItems?: number
  maxItems?: number
}

type ObjectTypedFieldExtras = {
  type: "object"
  shape: {
      [key: string]: TypedFieldExtras & { optional?: boolean, label: string }
  }
}

type TypedFieldExtras =
  StringTypedFieldExtras
  | NumberTypedFieldExtras
  | BooleanTypedFieldExtras
  | DateTypedFieldExtras
  | EnumTypedFieldExtras
  | ArrayTypedFieldExtras
  | ObjectTypedFieldExtras

and i would love to create zod schemas for those types.

I'm struggling on the ArrayTypedFieldExtras and ObjectTypedFieldExtras Schemas since they require the discriminated union of all schemas to work 😅

How would I provide those schemas if they are not defined at that point?

Edit

This is how my current approach looks:

Click to show

const StringTypedFieldExtrasSchema = z.object({
    type: z.literal("string"),
    matches: z.preprocess((arg, ctx) => {
        if (arg instanceof RegExp) return arg;
        if (typeof arg === "string") return new RegExp(arg);
        ctx.addIssue({
            code: z.ZodIssueCode.invalid_type,
            message: "Required",
            path: ctx.path,
            received: 'undefined',
            expected: typeof arg
        });
    }, z.instanceof(RegExp)).optional(),
    minLength: z.number().optional(),
    maxLength: z.number().optional()
})

export type StringTypedFieldExtras = z.infer<typeof StringTypedFieldExtrasSchema>

const NumberTypedFieldExtrasSchema = z.object({
    type: z.literal("number"),
    min: z.number().optional(),
    max: z.number().optional()
})

export type NumberTypedFieldExtras = z.infer<typeof NumberTypedFieldExtrasSchema>

const BooleanTypedFieldExtrasSchema = z.object({
    type: z.literal("boolean")
})

export type BooleanTypedFieldExtras = z.infer<typeof BooleanTypedFieldExtrasSchema>

const DateTypedFieldExtrasSchema = z.object({
    type: z.literal("date"),
    from: z.date().optional(),
    to: z.date().optional(),
    format: z.string().optional()
})

export type DateTypedFieldExtras = z.infer<typeof DateTypedFieldExtrasSchema>

const EnumTypedFieldExtrasSchema = z.object({
    type: z.literal("enum"),
    values: z.array(z.string()).nonempty(),
    valueFormatter: z.function().optional()
})

export type EnumTypedFieldExtras = z.infer<typeof EnumTypedFieldExtrasSchema>

const BaseArrayTypedFieldExtrasSchema = z.object({
    type: z.literal("array"),
    itemLabel: z.union([z.string(), z.function().args(z.number()).returns(z.string())]),
    minItems: z.number().optional(),
    maxItems: z.number().optional()
})

export type ArrayTypedFieldExtras = z.infer<typeof BaseArrayTypedFieldExtrasSchema> & {
    itemType: TypedFieldExtras
}

const ArrayTypedFieldExtrasSchema: z.ZodDiscriminatedUnionOption<"type"> = BaseArrayTypedFieldExtrasSchema.extend({
    itemType: z.lazy(() => TypedFieldExtrasSchema)
})

const BaseObjectTypedFieldExtrasSchema = z.object({
    type: z.literal("object"),
});

export type ObjectTypedFieldExtras = z.infer<typeof BaseObjectTypedFieldExtrasSchema> & {
    shape: {
        [key: string]: TypedFieldExtras & { optional?: boolean, label: string }
    }
}

const ObjectTypedFieldExtrasSchema: z.ZodDiscriminatedUnionOption<"type"> = BaseObjectTypedFieldExtrasSchema.extend({
    shape: z.record(z.string(), z.lazy(() => TypedFieldExtrasSchema.and(
        z.object({
            optional: z.boolean().optional(),
            label: z.string()
        })
    )))
});

export const TypedFieldExtrasSchema = z.discriminatedUnion("type", [
    StringTypedFieldExtrasSchema,
    NumberTypedFieldExtrasSchema,
    BooleanTypedFieldExtrasSchema,
    DateTypedFieldExtrasSchema,
    EnumTypedFieldExtrasSchema,
    ArrayTypedFieldExtrasSchema,
    ObjectTypedFieldExtrasSchema
])

export type TypedFieldExtras = z.infer<typeof TypedFieldExtrasSchema>

The issue with TypedFieldExtrasSchema in that case is that somehow the type field is typed as optional and unknown which is not accurate.