planner.cljc

(def inputs-outputs
  (let [person-out [:person/number
                    :person/name
                    :person/pet]
        pet-out [:pet/index
                 :pet/owner]]
    [{::pc/output [{:people/people person-out}]}

     {::pc/input #{:person/number}
      ::pc/output person-out}

     {::pc/output [{:person/pet pet-out}]}

     {::pc/output [{:pet/owner person-out}]}]))

(defn compute-indexes [resolver-sym ios]
  (reduce (fn [acc x] (pc/add acc resolver-sym x))
          {}
          ios))

(defn internalize-indexes
  [indexes {::pc/keys [sym] :as dynamic-resolver}]
  (-> indexes
    (update ::pc/index-resolvers
      (fn [resolvers]
        (into {}
          (map (fn [[r v]] [r (assoc v ::pc/dynamic-sym sym)]))
          resolvers)))
    (assoc-in [::pc/index-resolvers sym]
      dynamic-resolver)))

(def connect-plugin
  (let [resolver-sym        `test-resolver
        provided-indexes    (compute-indexes resolver-sym inputs-outputs)]
    {::p/wrap-parser2
     (fn [parser {::p/keys [plugins]}]
       (let [resolve-fn  (fn [env _] (println :foreign-ast (-> env ::pcp/node ::pcp/foreign-ast)))
             all-indexes (-> provided-indexes
                             (internalize-indexes
                              {::pc/sym               (gensym resolver-sym)
                               ::pc/cache?            false
                               ::pc/dynamic-resolver? true
                               ::pc/resolve           resolve-fn}))
             idx-atoms   (keep ::pc/indexes plugins)]
         (doseq [idx* idx-atoms]
           (swap! idx* pc/merge-indexes all-indexes))
         (fn [env tx] (parser env tx))))}))

(let [main [:person/name
            {:person/pet [{:pet/owner [:person/name]}]}]

      q-1
      [{[:person/number 1] main}]

      q-2
      [{:people/people main}]

      parser
      (p/async-parser
       {::p/env {::p/reader [p/map-reader
                             pc/reader3
                             pc/open-ident-reader
                             p/env-placeholder-reader]}
        ::p/plugins [(pc/connect-plugin {::pc/register []})
                     connect-plugin]})]
  (go (println (<! (parser {} q-1)))))

The resolver function does nothing but prints out foreign-ast (see line 38).
Query q-2 works the same in clj and cljs, while q-1 does not.
in cljs, for query q-1, the resolver prints out :foreign-ast {:type :root, :children [{:type :prop, :dispatch-key :person/name, :key :person/name} {:type :join, :dispatch-key :person/pet, :key :person/pet, :query [{:pet/owner []}], :children [{:type :join, :dispatch-key :pet/owner, :key :pet/owner, :query [nil], :children []}]}]}. The expected should be like in clj, or in the main part of q-2