Passing Data Down to Other Resolvers

[dehli]

Hi and happy holidays! I have a question around passing data down to sub-resolvers.
Let's say I wanted to get the inventory of all items at a specific store.

My EQL might look like:

[{[:store/id 1]
  [{:items/all [:store-item/inventory]}]}]

I then might have the following resolvers to fulfill this query:

(pc/defresolver all-items
  [_]
  {::pc/output [{:items/all [:item/id]}]}
  {:items/all [{:item/id 0}
               {:item/id 1}
               {:item/id 2}]})

(pc/defresolver store-item-inventory
  [{item-id :item/id store-id :store/id}]
  {:store-item/inventory (+ item-id store-id)})

However, this won't work because inside of the context of :items/all
there's no :store/id (since it's only accessible at the top-level).

What is the recommended way to solve for this? Thanks so much!

[wilkerlucio]

Hello, happy holidays too! 🎄

There are two approaches I see for this case:

1. Item probably has some association with a story, so you can some resolver that goes from :item/id to :store/id
2. If you depend on the store id in all-items, you can add it to the data downwards:

(pc/defresolver all-items
  [{:keys [store/id]}]
  {::pc/output
   [{:items/all
     [:item/id :store/id]}]}
  {:items/all
   (mapv
     #(assoc % :store/id id)
     [{:item/id 0}
      {:item/id 1}
      {:item/id 2}])})

(pc/defresolver store-item-inventory
  [{item-id :item/id store-id :store/id}]
  {:store-item/inventory (+ item-id store-id)})

[dehli]

Thanks so much for your help! I'll play around with both of those ideas.

[wilkerlucio]

Glad to help, another note, if you take option 1, try to make a batch out of it, so you can have a single request to get all store-ids (if possible, could be a batched API call, a batched DB request, etc...).

[dehli]

Hello again! I figured I'd keep the discussion here since it's still related to the initial question. I'm wanting to do something like below:

[{:items/all
  [:item/id
   {[:store/id "foo"]
    [:store-item/inventory]}
   {[:store/id "bar"]
    [:store-item/inventory]}]}]

Although :item/id exists above the ident, the resolver underneath the ident doesn't have access to it (:store-item/inventory). Is something like this possible? Thanks again for all your help and suggestions!

[wilkerlucio]

Pathom 3 has a feature to fix it, using placeholders you could write it as:

[{:items/all
  [:item/id
   {(:>/foo-store {:store/id "foo"})
    [:store-item/inventory]}
   {(:>/bar-store {:store/id "bar"})
    [:store-item/inventory]}]}]

This doesn't work by default in Pathom 2, but you can make a custom placeholder reader that supports it. Here is a full example:

(defn params-placeholder-reader
  "Copied from p/env-placeholder-reader and modified to add param data to the entity."
  [{::p/keys [placeholder-prefixes] :as env}]
  (assert placeholder-prefixes "To use env-placeholder-reader please add ::p/placeholder-prefixes to your environment.")
  (if (p/placeholder-key? env (-> env :ast :dispatch-key))
    (let [params  (-> env :ast :params)
          new-ent (merge (p/entity env) params)]
      (p/join (assoc env ::p/entity (atom new-ent))))
    ::continue))

(pc/defresolver all-items []
  {:items/all
   [{:item/id 1}
    {:item/id 2}]})

(pc/defresolver inventory [{item-id  :item/id
                            store-id :store/id}]
  {:store-item/inventory (str item-id " - " store-id)})

(def registry
  [all-items
   inventory])

(def parser
  (p/parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/reader2
                                            pc/open-ident-reader
                                            ; here I replaced the placeholder reader
                                            params-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate
     ::p/plugins [(pc/connect-plugin {::pc/register registry})
                  p/error-handler-plugin
                  p/trace-plugin]}))

(comment
  (parser {}
    '[{:items/all
       [:item/id
        {(:>/foo-store {:store/id "foo"})
         [:store-item/inventory]}
        {(:>/bar-store {:store/id "bar"})
         [:store-item/inventory]}]}]))

That said, I consider if that really makes sense, because ad-hoc data like this is usually useful for exploration, but for users, it's more common to have specific edges (with names) so the user doesn't have to juggle the query for it.

[dehli]

Awesome! That seems like a really neat feature of Pathom 3 and I appreciate you showing how I can implement it in Pathom 2. I don't entirely understand your comment here:

That said, I consider if that really makes sense, because ad-hoc data like this is usually useful for exploration, but for users, it's more common to have specific edges (with names) so the user doesn't have to juggle the query for it.

Are you suggesting writing a single function that does all the logic in the various composed resolvers? Something like below. It seems like I'd miss out on some of the composability of resolvers that pathom gives me if I were to go this route.

(pc/defresolver single-resolver
  [{store-ids :store/ids}]
  {:store/data (db/get-store-data store-ids)})

Or are you suggesting having a single resolver that would call out to the parser with the more complicated query? Something like below.

(pc/defresolver single-resolver
  [{:keys [parser] :as env} {store-ids :store/ids}]
  (parser env [{:items/all [:item/id ...]}]))

Or were you suggesting something else? 😄

Thanks again!