Patterns for Example Usage?

[makeitrein]

Amazing library, but I'm actually a bit overwhelmed with how many zod schemas it's generated... I've got 12,000 lines of zod schemas from a fairly small prisma.schema file!

This library in conjunction with z.infer<typeof SomeGeneratedZodSchema> seems to offer a nice blend of runtime and compile time type safety, but would definitely appreciate some guidance on how to best use the schemas for maximum benefit and clarity.

For example, here's some generated code for my AbiItem prisma model...

Which of the 75 generated AbiItem schemas should I make my CRUD functions conform to?

[nordowl]

I'm using zod-prisma-types together with tRPC, and I have come up with this pattern:

I have so called entities, for example this user entity, which contains some reusable functions

import { db } from "../../config/initialize/prisma.init"
import { UserFindUniqueArgsSchema, UserFindManyArgsSchema } from "mypackage/types"
import { z } from "zod"

const user = {
    // Get a single user
    async getOne(opts: z.infer<typeof UserFindUniqueArgsSchema>) {
        const user = await db.user.findUnique({
            ...opts,
        })
        return user
    },
    // Get many users
    async getMany(opts: z.infer<typeof UserFindManyArgsSchema>) {
        const users = await db.user.findMany({
            ...opts,
        })
        return users
    },
}

export default user

Not sure why I decided to spread the opts. You could just pass opts to the Prisma functions.

And then I have my routers which use those entities

import { t, adminProcedure } from "@/trpc"
import { user } from "@/entities"
import { z } from "zod"
import { UserFindUniqueArgsSchema, UserFindManyArgsSchema } from "mypackage/types"

// All endpoints for user
export const userRouter = t.router({
    // Get one user
    getOne: adminProcedure.input(UserFindUniqueArgsSchema).query(async ({ input }) => {
        const userdata = await user.getOne(input)
        return userdata
    }),

    // Get many users
    getMany: adminProcedure.input(UserFindManyArgsSchema).query(async ({ input }) => {
        const users = await user.getMany(input)
        return users
    }),
})

And writing queries in my Next.js frontend I get full type safety.

const { data } = trpc.user.getOne.useQuery({
    where: { id: "whatever" }
})

[chrishoermann]

As mentioned by @nordowl most of the types are useful when using trpc or when you need to expose the types of prisma queries and mutations to a fetch library like @tanstack/query or similar. The model types also can be useful when validating form inputs in react-hook-form or other form management libraries that allow zod schemas as validation source.

[makeitrein]

Gotcha! I'm using Remix, so I've started to explore this pattern:

/*Hooks that infer type of schema */
export function useSubmitVisualizationCreate() {
  const fetcher = useFetcher();
  const submit = useCallback(
    (visualization: z.infer<typeof VisualizationCreateSchema>) => {
      fetcher.submit(visualization, {
        method: "POST",
        encType: "application/json",
        action: "/api/visualization/create",
      });
    },
    [fetcher]
  );
  return submit;
}

/* Actions that parse schema */
export const action = async ({ request }: ActionArgs) => {
  try {
    const payload = VisualizationCreateSchema.parse(await request.json());

I've been happy with this pattern for POSTS, but still a bit shaky on GETS...

One thing in particular I'm hung up on is how best to capture the schema/type of the return type from prisma queries that use permutations of other relationships.

e.g.

I'm trying to figure out how to type these two different Substreams for my React components - is there a generated type or a pattern here to help with this use case?

[nordowl]

One thing in particular I'm hung up on is how best to capture the schema/type of the return type from prisma queries that use permutations of other relationships.

I'm trying to figure out how to type these two different Substreams for my React components - is there a generated type or a pattern here to help with this use case?

As far as I know, the return type for when you are querying a unique substream should be SubstreamSchema | null (given you're using the types generated by zod-prisma-types). It gets a bit trickier when you want to include related data.
zod-prisma-types luckily generates a type of your model that includes relations. In your case I would use SubstreamWithRelationsSchema | null. This will have all the relations.

If you only want to include a few relations, like in your second example, I'd do something like this:
SubstreamSchema & { blockchain: BlockchainSchema } & { user: UserSchema } | null

While that is certainly not the cleanest solution, it should just do the trick.

[makeitrein]

That'll work great for my use case - thx!