Generic prisma pagination

[nikatsapien]

Hi folks!

We extend our prisma client with a pagination method that's applied to all models:

const prisma = new PrismaClient().$extends({
  model: {
    $allModels: {
      async paginate<T, A>(
        this: T,
        options: Omit<Prisma.Args<T, 'findMany'>, 'include' | 'select'>,
      ): Promise<{ data: Prisma.Result<T, A, 'findMany'>; skip: number; take: number; count: number }> {
        const { where, skip, take, orderBy } = options;

        const context = Prisma.getExtensionContext(this);

        const count = await (context as any).count({ where });
        const data = await (context as any).findMany({ where, skip, take, orderBy });

        return {
          take,
          skip,
          count,
          data,
        };
      },
    },
  },
});

We have queryFields that resolve with both pagination metadata and query data. The query data is a paginated type. An example of this whole pattern is below:

import assert from 'node:assert';
import { User as UserModel } from '@prisma/client';

export type PaginatedDataShape<T> = {
  take: number;
  skip: number;
  count: number;
  data: T[];
};

// User type is from the prisma-generated types
const PaginatedUser = builder.objectRef<PaginatedDataShape<UserModel>>('PaginatedUser');

builder.objectType(PaginatedUser, {
  description: 'Paginated version of the User type',
  fields: t => ({
    take: t.exposeInt('take'),
    skip: t.exposeInt('skip'),
    count: t.exposeInt('count'),
    data: t.prismaField({
      type: ['User'],
      resolve: async (query, parent, _args, context, _info) => {
        const data = await context.prisma.user.findMany({
          ...query,
          where: {
            id: { in: parent.data.map(obj => obj.id) },
          },
        });

        return parent.data.map(pd => {
          const cd = data.find(d => d.id === pd.id);
          assert(cd, 'Parent data not found');
          return cd;
        });
      },
    }),
  }),
});

type ResolveUserArgs = {
  context: GraphQLContext;
  input: {
    skip: number;
    take: number;
  };
};

const resolveUser = async ({ input, context }: ResolveUserArgs) => {
  return context.prisma.user.paginate({
    skip: input.skip,
    take: input.take,
  });
};

builder.queryField('user', t =>
  t.fieldWithInput({
    input: {
      take: t.input.int({ required: true }),
      skip: t.input.int({ required: true }),
    },
    type: PaginatedUser,
    resolve: async (_root, args, context: GraphQLContext, _info) => {
      return resolveUser({ input: args.input, context });
    },
  }),
);

export const User = builder.prismaObject('User', {
  fields: t => ({
    id: t.exposeID('id'),
    email: t.exposeString('email', { nullable: true }),
    firstName: t.exposeString('firstName', { nullable: true }),
    lastName: t.exposeString('lastName', { nullable: true }),
    numberOfFriends: t.relationCount('friends'),
  }),
});

This generally works for us, but we have what feels like an unnecessary prisma call to re-retrieve the models by ids (and an unnecessary re-sort), as seen in the PaginatedUser resolver.

I am wondering if anyone has any recommendations for how to remove this second prisma call, while also retaining nested resolvers. For example, if resolverUser just returns parent.data, we lose access to downstream resolvers, and the numberOfFriends field on the User type cannot be resolved.

Alternatively, we may be approaching pagination wrong, and there may be an easier approach.

Thanks for any help!

[nikatsapien]

Just checking in to see if anyone has any thoughts on this, or has any recommendations on generic offset-based pagination with Pothos and Prisma 🙏

[hayes]

You can definitely avoid the extra queries. There are a few different options here, but I think the easiest would be to use the queryFromInfo helper to directly load nested selections, and maybe add in the simpleObjects plugin for the extra pagination types

import assert from 'node:assert';
import { User as UserModel } from '@prisma/client';
import { queryFromInfo } from '@pothos/plugin-prisma';

builder.simpleObject('PaginatedUser', {
  description: 'Paginated version of the User type',
  fields: t => ({
    take: t.int(),
    skip: t.int(),
    count: t.int(),
    data: t.field({
      type: User,
    }),
  }),
});

type ResolveUserArgs = {
  query: {}, // { select?: UserSelect, include?: UserInclude } 
  context: GraphQLContext;
  input: {
    skip: number;
    take: number;
  };
};

const resolveUser = async ({ query, input, context }: ResolveUserArgs) => {
  return context.prisma.user.paginate({
    // assumes that your paginate can take arbitrary select/include options
    ...query,
    skip: input.skip,
    take: input.take,
  });
};

builder.queryField('user', t =>
  t.fieldWithInput({
    input: {
      take: t.input.int({ required: true }),
      skip: t.input.int({ required: true }),
    },
    type: PaginatedUser,
    resolve: async (_root, args, context: GraphQLContext, info) => {
      return resolveUser({
        query: queryFromInfo({
          path: ['data'],
          info,
          context,
        }),
        input: args.input,
        context
      });
    },
  }),
);

export const User = builder.prismaObject('User', {
  fields: t => ({
    id: t.exposeID('id'),
    email: t.exposeString('email', { nullable: true }),
    firstName: t.exposeString('firstName', { nullable: true }),
    lastName: t.exposeString('lastName', { nullable: true }),
    numberOfFriends: t.relationCount('friends'),
  }),
});

I didn't test this, but this general pattern should work pretty well to eliminate extra requests

[nikatsapien]

Sorry about the late response. We've been running with this general concept for some time, and it's working great. Thanks for the in-depth knowledge of Graphql (and the GraphQL context object, more specifically), @hayes!