[Question] Is there any way to add the prisma types with non prisma types to builder.ObjectType

[ChamaraWP]

I'm trying to implement offset-based pagination for one of my resolvers. when the resolver executes I want to return a payload that looks like this

{
 hasNext: true,
 hasPrevious: false,
 count: 14,
 data:// This has to be the array of prisma object
}

To achieve this I created to type

export type PaginatedUserType = {
    hasNext: boolean,
    hasPrevious: boolean,
    count: number
    leave:[user] <----- Prisma type
}

and wants to build the objectType out of the above type

builder.objectType("PaginatedUserType", {
  fields:(t) => ({
    hasNext: t.exposeBoolean("hasNext"),
    hasPrevious: t.exposeBoolean("hasNext"),
    count: t.exposeInt("count"),
    data: t.expose("users",{ type: "user"}) <------ can't figure out how to get the correct reference here
  })
})

I'm not sure my approach is correct. I went through the doc but it's a bit hard to understand for me. I post this question SO as well but couldn't get any luck

[hayes]

builder.prismaObject returns a ref you can use as the type for fields

[ChamaraWP]

thanks for the quick reply I tried this solution.getting this error

[hayes]

You can get a better error by using t.field with a resolver that returns the data property

[hayes]

For an array of users, you would need to use [userRef]

[ChamaraWP]

it worked

[matthawk60]

@ChamaraWP I saw your post on stack overflow, could you post your entire solution. I need offset pagination to use Apollo client to get page numbered displays. The relay pagination support just does continuous scroll.

[ChamaraWP]

Hey, @matthawk60 here is the solution. hope this will help

builder.objectType("PaginatedLeaveType", {
  description:"Type used for querying the paginated leaves and it's paginated meta data",
  fields: (t) => ({
    nextPage: t.exposeInt("nextPage", { nullable: true }),
    prevPage: t.exposeInt("prevPage", { nullable: true }),
    total: t.exposeInt("total"),
    leave: t.expose("leaves", { type: [leaveRef] }),
  }),
});

builder.queryField("paginatedLeave", (t) =>
  t.field({
    type: "PaginatedLeaveType",
    args: {
      page: t.arg.int(),
      take: t.arg.int(),
      orderBy: t.arg({
        type: AcceptableOrderByTypes,
      }),
      status: t.arg({
        type: AcceptableLeaveStatus,
      }),
      empId: t.arg.string(),
    },
    resolve: async (_, args) => {
      const { status, orderBy, empId } = args;
      const page = args.page || 1;
      const take = args.take || 10;
      const skip = (page - 1) * take;

      const count = await db.leave.count({
        where: {
          AND: [
            {
              leaveStatus: {
                status: status ?? undefined,
              },
            },
            {
              employeeId: empId ?? undefined,
            },
          ],
        },
      });
      const leaves = await db.leave.findMany({
        where: {
          AND: [
            {
              leaveStatus: {
                status: status ?? undefined,
              },
            },
            {
              employeeId: empId ?? undefined,
            },
          ],
        },
        orderBy: {
          createdAt: orderBy ?? undefined,
        },
        skip: skip,
        take: take,
      });

      const paginateMetaData = getPaginationMetaData(page, take, count);

      return { ...paginateMetaData, leaves };
    },
  })
);