pathom-connect-dynamic-resolver.cljs

(let [the-parser
      (p/parser
        {::p/env     {::p/reader               [p/map-reader
                                                pc/reader2
                                                pc/open-ident-reader
                                                p/env-placeholder-reader]
                      ::p/placeholder-prefixes #{">"}}
         ::p/mutate  pc/mutate
         ::p/plugins [(pc/connect-plugin {::pc/register []})
                      {::p/intercept-output (fn [env v] v)
                       ::p/wrap-parser2
                       (fn [parser {::p/keys [plugins]}]
                         (let [resolver `my-resolver
                               my-provides #:x{:t {}, :u {}, :v {} :id {}}
                               my-resolve (fn [env _]
                                            (println "got this p query: " (::p/parent-query env))
                                            (println "got this ast " (:ast env))
                                            (println "got this entity " (::p/entity env))
                                            {:a/x #:x{:t 1 :u 2 :v 3}})
                               index-oir
                               (merge
                                 {:a/x {#{} #{resolver}}}
                                 #:x{:t {#{:a/x} #{resolver}},
                                     :u {#{:a/x} #{resolver}},
                                     :v {#{:a/x} #{resolver}}})
                               index-io {#{} {:a/x {:x/t {} :x/u {} :x/v {}}}
                                         #{:a/x} #:x{:t {}, :u {}, :v {}}}
                               index-idents #{:x/id}
                               all-indexes {::pc/index-resolvers
                                            {resolver {::pc/sym               resolver
                                                       ::pc/cache?            false
                                                       ::pc/dynamic-resolver? true
                                                       ;::pc/provides          my-provides
                                                       ::pc/output []
                                                       ::pc/resolve           my-resolve}}

                                            ::pc/index-oir
                                            index-oir

                                            ::pc/index-io
                                            index-io

                                            ::pc/idents
                                            index-idents

                                            ::pc/autocomplete-ignore
                                            #{}}
                               idx-atoms (keep ::pc/indexes plugins)]
                           (doseq [idx* idx-atoms]
                             (swap! idx* pc/merge-indexes all-indexes))
                           (fn [{::keys [] :as env} tx]
                             (parser env tx))))}
                      p/error-handler-plugin
                      p/trace-plugin]})]
  (the-parser {:o :ri}
    [{:a/x [:x/t {:>/go [:x/u]} :x/v]}
     #_{[:x/id 1] [:x/t]}]))