Hi, I’m exploring the features of Pathom. I’m wondering is there a builtin way to merge independent queries during one request. E.g. I would have an html page with independent blocks.

[:div
 [:div {:class "block 1"}
   (q [:album/name
       {:album/artist
        [:artist/name]}])]
 [:div {:class "block 2"}
   (q [:album/name
       {:album/tracks
        [:track/name]}])]]

[:album/name
 {:album/tracks
  [:track/name]
  :album/artist
  [:artist/name]}]

Yes, Fulcro does this automatically

http://book.fulcrologic.com/#_server_interaction_order

Thanks, good to know. But is not part of Panthom? So I have to steal that there. (i’m not using Fulcro)

Maybe I’m looking for the Request cache (mentioned in the introduction). I’ll have a read

Request cache: For caching the results of parsing repetition that can happen on a single request.

those are separate ideas

you can easily merge separate EQL queries into one (if they do not have conflicts)

then that single EQL query resolution can be made more efficient inside Pathom using the request cache (and other techniques)

https://github.com/edn-query-language/eql/blob/master/src/edn_query_language/core.cljc#L532-L536

this is what you are looking for probably

ah thanks

I’ll do some reading and give this a try later

@jeroenvandijk just "merge" your queries

(let [{:>/keys [a b]} (q [{:>/a [:album/name
                                 {:album/artist
                                  [:artist/name]}]}
                          {:>/b [:album/name
                                 {:album/tracks
                                  [:track/name]}]}])]
  [:div
   [:div {:class "block 1"}
    a]
   [:div {:class "block 2"}
    b]])

Also you can use ::p/entity

(let [a (atom 0)
      register [(pc/resolver
                  `a 
                  {::pc/output [:a]}
                  (fn [_ _]
                    {:a (swap! a inc)}))]
      parser (p/parser {::p/plugins [(pc/connect-plugin {::pc/register register})]})
      env {::p/reader [p/map-reader
                       pc/reader2
                       pc/open-ident-reader
                       p/env-placeholder-reader]
           ::p/placeholder-prefixes #{">"}}
      ->cache (fn [parser]
                (let [entity (atom {})]
                  (fn [tx]
                    (parser (assoc env ::p/entity entity)
                            tx))))
      single-use-cached-parser (->cache parser)]
  [:without-cache [:div 
                   (parser env [:a])
                   (parser env [:a])]
   :with-cache [:div
                (single-use-cached-parser [:a])
                (single-use-cached-parser [:a])]])