Help me make a recursive zod v4 schema for my interface

[alekseykurylev]

Help me make a recursive zod v4 schema for my interface
I can't seem to get the desired result. And I don't understand how to do recursive schemes correctly in zod v4.

interface FieldBase {
  id: string;
  name: string;
  label: string;
  description: string;
}

interface FieldText extends FieldBase {
  type: "text";
  value: string;
}

interface FieldNumber extends FieldBase {
  type: "number";
  value: number;
}

interface GroupList {
  type: "group-list";
  items: Record<string, Item>[];
}

type Item = GroupList | Group | Form | FieldText | FieldNumber;

interface DynamicFormBase {
  id: string;
  label: string;
  items: Record<string, Item>;
}

interface Group extends DynamicFormBase {
  type: "group";
}

interface Form extends DynamicFormBase {
  type: "form";
  params: Record<string, unknown>;
}

export type DynamicForm = Group | Form;

[alekseykurylev]

It looks strange and unreliable, but I haven't found any other solution.

onst FieldBaseSchema = z.object({
  id: z.string(),
  name: z.string(),
  label: z.string(),
  description: z.string(),
});

const FieldTextSchema = z.object({
  ...FieldBaseSchema.shape,
  type: z.literal("text"),
  value: z.string(),
});

const FieldNumberSchema = z.object({
  ...FieldBaseSchema.shape,
  type: z.literal("number"),
  value: z.number(),
});

const ItemSchema: z.ZodType<TItem> = z.lazy(() =>
  z.discriminatedUnion("type", [
    FieldTextSchema,
    FieldNumberSchema,
    GroupListSchema,
    GroupSchema,
    FormSchema,
  ]),
);

const GroupListSchema = z.object({
  type: z.literal("group-list"),
  items: z.array(z.record(z.string(), ItemSchema)),
});

const DynamicFormBaseSchema = z.object({
  id: z.string(),
  label: z.string(),
  items: z.record(z.string(), ItemSchema),
});

const GroupSchema = z.object({
  ...DynamicFormBaseSchema.shape,
  type: z.literal("group"),
});

const FormSchema = z.object({
  ...DynamicFormBaseSchema.shape,
  type: z.literal("form"),
  params: z.record(z.string(), z.unknown()),
});

export const DynamicFormSchema = z.discriminatedUnion("type", [
  GroupSchema,
  FormSchema,
]);

export type DynamicForm = z.infer<typeof DynamicFormSchema>;

// 🤷🤷🤷
type TItem =
  | z.infer<typeof FieldTextSchema>
  | z.infer<typeof FieldNumberSchema>
  | {
      type: "group-list";
      items: Record<string, TItem>[];
    }
  | {
      type: "group";
      id: string;
      label: string;
      items: Record<string, TItem>;
    }
  | {
      type: "form";
      id: string;
      label: string;
      items: Record<string, TItem>;
      params: Record<string, unknown>;
    };