Accessing parent resolver args

[codepunkt]

Is it possible to access parent resolver args?

E.g. how would I access the currency arg from the top-level cart query in the formatted field resolver for the Money object ref when sending a query like this - to have all prices formatted with EUR?

{
  cart(id: "59ca922e-a045-445a-9438-f03df4901b0a", currency: "EUR") {
    id
    subTotal {
      amount
      formatted
    }
    items {
      id
      name
      quantity
      lineTotal {
        amount
        formatted
      }
      unitTotal {
        amount
        formatted
      }
    }
  }
}

import SchemaBuilder from '@pothos/core'
import WithInputPlugin from '@pothos/plugin-with-input'
import z from 'zod'

const CartItem = z.object({
  id: z.string().uuid(),
  name: z.string(),
  price: z.number(),
  quantity: z.number(),
})

const Cart = z.object({
  id: z.string().uuid(),
  items: z.array(CartItem).optional(),
})

const builder = new SchemaBuilder<{
  Objects: {
    Cart: z.infer<typeof Cart>
    CartItem: z.infer<typeof CartItem>
  }
  Scalars: {
    ID: { Input: string; Output: string }
  }
}>({
  plugins: [WithInputPlugin],
})

const CARTS = [
  {
    id: '59ca922e-a045-445a-9438-f03df4901b0a',
    items: [
      { id: 'c4543662-38f5-450d-b8e3-fcd45d1f6149', name: 'My item', price: 1000, quantity: 1 },
    ],
  },
]

const Money = builder.objectRef<number>('Money').implement({
  fields: t => ({
    amount: t.int({ resolve: amount => amount }),
    formatted: t.string({
      resolve: amount =>
        new Intl.NumberFormat('en-US', {
          style: 'currency',
          currency: 'USD',
        }).format(amount / 100),
    }),
  }),
})

builder.objectType('Cart', {
  fields: t => ({
    id: t.exposeString('id'),
    items: t.field({
      type: ['CartItem'],
      resolve: cart => cart.items ?? [],
    }),
    subTotal: t.field({
      type: Money,
      resolve: cart =>
        cart.items?.reduce(
          (acc, item) => acc + item.price * item.quantity,
          0,
        ) ?? 0,
    }),
  }),
})

builder.objectType('CartItem', {
  fields: t => ({
    id: t.exposeString('id'),
    name: t.exposeString('name'),
    quantity: t.exposeInt('quantity'),
    lineTotal: t.field({
      type: Money,
      resolve: item => item.price * item.quantity,
    }),
    unitTotal: t.field({
      type: Money,
      resolve: item => item.price,
    }),
  }),
})

builder.queryType({
  fields: t => ({
    cart: t.field({
      nullable: true,
      args: {
        id: t.arg.id({ required: true }),
        currency: t.arg.string({ required: false, defaultValue: 'USD' }),
      },
      type: 'Cart',
      resolve: (_, { id }) => {
        const cart = CARTS.find(c => c.id === id)

        if (!cart)
          throw new Error(`No cart with ID: ${id}`)

        return cart
      },
    }),
  }),
})

builder.mutationType({
  fields: t => ({
    addItem: t.fieldWithInput({
      input: {
        cartId: t.input.id({ required: true }),
        id: t.input.id({ required: true }),
        name: t.input.string({ required: true }),
        price: t.input.int({ required: true }),
        quantity: t.input.int({ defaultValue: 1, required: true }),
      },
      type: 'Cart',
      resolve: (_, { input: { cartId, ...input } }) => {
        const cart = CARTS.find(c => c.id === cartId)

        if (!cart)
          throw new Error(`No cart with ID: ${cartId}`)

        return {
          id: cartId,
          items: [...cart?.items, input],
        }
      },
    }),
  }),
})

export default builder.toSchema()

[hayes]

There isn't a great way to do this. This is more of a general GraphQL issue than something specific to pothos.

There are 2 ways you can get those arguments:

• You can pass them down by attaching them to the value returned from the resolver. If you are trying to pass it down several layers this can get pretty annoying
• You can extract the arguments from the query using the info object (4th argument of a resolver). This isn't straight forward, and requires you to manually find the right selection, and then use the getArgumentValues helper from graphql to extract the arguments. This also will bypass certain things like validation, and parsing logic in resolvers, for example the decoding of global ID arguments in the relay plugin.

I don't currently have a better suggestion

[codepunkt]

Thanks!

I added it to the context in the parent resolver, which should be recreated per request. That's straight-forward, but not type-safe as I don't know beforehand which args or other things I might add to it in addition to what's normally there. I wondered if there was a better way specific to pothos, which seems like there isn't.

I know that the example is kinda strange, so sorry about that. If this was really my use-case, I should probably do the formatting on the client 😅

[hayes]

I've been thinking about adding a helper like:

that would allow you to do something like getResolvedArguments(info, info.path.prev.prev) that would let you get arguments at a specific path, and include any transformations or validation from various pothos plugins, but haven't gotten around to it yet.