Project relation with custom resolver logic

[marceloverdijk]

I'm trying to figure out how to make a relation (1-N) pageable.
Checking the docs I read about custom resolver logic and wrapping the default resolver:

objectType({
  name: User.$name,
  definition(t) {
    t.field(User.id)
    t.field({
      ...User.posts,
      async resolve(...args) {
        // Your custom before-logic here
        const result = await User.posts.resolve(...args)
        // Your custom after-logic here
        return result
      },
    })
  },
})

So I added first and offset arguments like.

objectType({
  name: User.$name,
  definition(t) {
    t.field(User.id)
    t.field({
      ...User.posts,
      args: {
        first: intArg(),
        offset: intArg(),
      }
      async resolve(...args) {

        // How can I now translate the first/offset args to Prisma's take/skip and calling the wrapped resolver?
        // Or should I not call the wrapper resolved at all?

        const result = await User.posts.resolve(...args)
        return result
      },
    })
  },
})

But I don't understand how to integrate these first and offset arguments now...
Probably easy but I just can find it... any help appreciated.

[marceloverdijk]

This woks:

objectType({
  name: User.$name,
  definition(t) {
    t.field(User.id)
    t.field({
      ...User.posts,
      args: {
        first: intArg(),
        offset: intArg(),
      }
      resolve(parent, args, ctx) {
        return ctx.prisma.user
          .findUnique({ where: { id: parent.id } })
          .posts({
            take: args.first ?? undefined,
            skip: args.offset ?? undefined,
          })
      },
    })
  },
})

But I wonder if there is a simpler/better way to do this instead?

As I basically want to add such a paging to every array type in my GraphQL model, this will be quite some repetitive code I'm afraid of.