How to wrap a Prisma method and reuse types

Prisma is an easy to use ORM with really useful Typescript types that change the result type of a query based on the options you pass in.

While building out an application, you'll undoubtedly run into a situation where you want to wrap an existing Prisma method with custom logic. You may decide to pass-through the types so that the caller can decide if they want to extend query.

If you're using Prisma's query arguments, you'll also expect to get Prisma's return types.

This is not as easy as it sounds, as simply passing the data (or even passing a generic backed value) does not work as intended.

You may start by trying something like this. Wrapping the todo findMany call with a function that accepts Prisma query args, but modifies the query to do something specific.

// DOES NOT WORK
  specialFindMany<T extends Prisma.TodoFindManyArgs>(args?:T){
    return prisma.todo.findMany({
      ...args,
      where:{
        ...args?.where
        isSpecial: true
      }
    })
  }

This will produce type errors.

Discovery

As with anything in Typescript, if you dig into the types, you can get at what a function actually expects.

Looking at the types for todo.findMany() as of Prisma 2.24.0 you'll find something that looks like this:

findMany<T extends TodoFindManyArgs>(
      args?: SelectSubset<T, TodoFindManyArgs>
    ): CheckSelect<T, PrismaPromise<Array<Todo>>, PrismaPromise<Array<TodoGetPayload<T>>>>

You can see that they're pulling the type from SelectSubsets generics.

Solution

If you copy this type into both your method's declaration as well as the prisma.finyMany generic, you'll get a working typed passthrough.

   async specialFindMany<T extends Prisma.TodoFindManyArgs>(
    args?: Prisma.SelectSubset<T, Prisma.TodoFindManyArgs>,
  ) ){
    // Other custom logic

    const result = await prisma.todo.findMany<
    Prisma.SelectSubset<T, Prisma.SearchFindManyArgs>>(
      {
      ...args!,
      where:{
        ...args?.where
        isSpecial: true
      }
    })

    // Other custom logic

    return result
  }

Without passing in the generic, the types will still fail to pass through (at least in my testing).

Since args is optional, the types will complain about forcing an object through. There may be a better solution to this, but I simply ! forced the args type to exist.

Conclusion

This feels pretty cumbersome, and I'd love to see some more flexible typing in Prisma, but it gets the job done for wrapping database calls.

This solution unfortunately doesn't cover extending the types that go into the Prisma call, so including include or select will not result in proper output types.

If you have a better solution, please let me know in the comments!!!