Using Zod as the typing source through an application

[BlueskyFR]

Hey guys!
Just discovering zod - so let's say I have a schema like

let userSchema = z.object({ name: z.string(), type: z.enum(["Person", "Robot"]) })

and then I have a function somewhere like

function myfn(userType: XXX) {
    ...
}

What do I replace XXX with?

I don't want to have to define an external enum since I already have it defined with Zod from before. Also I'm not going to write z.infer<typeof userSchema.shape.type>() everywhere since it's ugly?

Just trying to wrap my head around that typing problem, since z.object and z.enum don't return types but Zod objects so they are incompatible with the rest of my app for typing purposes and I don't wanna have duplicated stuff.

So I guess I'm missing something here.

Thanks in advance for your help!

[ravinggenius]

I use the following approach, and it's been working well so far:

// schema.ts

import { z } from "zod";

export const USER = z.object({ name: z.string(), type: z.enum(["Person", "Robot"]) });

export interface User extends z.infer<typeof USER> {}
// or export type User = z.infer<typeof USER>;

// whatever.ts

import { User } from "./schema.ts";

export const (userType: User["type"]) => {
  ...
};

1. Defining the schema in a separate file allows schemas (and types) to be shared between the client and server in a full-stack app (like in Next)
2. I nearly always define a type right below the schema
3. I define the type as an interface so VS Code doesn't cover my whole window with the tooltip when hovering over the type. (The "type" tootip is fine for smaller types, but for larger/nested types, it is just too much. Define it both ways and hover over them to see what I mean)

[BlueskyFR]

Thanks for the answer, this is very helpful!
I'll just see if there are more replies to see other ways of doing it!

[robokozo]

Have you considered using nativeEnum?

https://zod.dev/?id=native-enums

This way you can define the enum in 1 place and use it throughout your app without having to go through the User

[ravinggenius]

Personally I'd stay away from TypeScript "native" enums. Just stick with string literal unions (z.enum() as above).

[robokozo]

Personally I'd stay away from TypeScript "native" enums. Just stick with string literal unions (z.enum() as above).

I don't use them but I know some people do. I follow the advice here: https://dev.to/ivanzm123/dont-use-enums-in-typescript-they-are-very-dangerous-57bh

That being said, I would personally prefer using an enum over User["type"]

[BlueskyFR]

yeah it is a bit weird, although I would try to avoid native enums too...

[ravinggenius]

I use indexed access types all the time. If you like you can always create an alias:

// schema.ts

import { z } from "zod";

export const USER = z.object({ name: z.string(), type: z.enum(["Person", "Robot"]) });

export interface User extends z.infer<typeof USER> {}
// or export type User = z.infer<typeof USER>;

export type UserType = User["type"];

// whatever.ts

import { UserType } from "./schema.ts";

export const (userType: UserType) => {
  ...
};

It's exactly the same thing, but I guess some people would say it looks nicer.

[BlueskyFR]

Thanks for your answer! In the end I just accepted that indexed types is how it is going to look after all...
I was just waiting for more answers to know if there was a really different approach than that tbh.