[2.3.0-alpha5] reader2 and reader3 do different things in ast

(for [reader [pc/reader2
              pc/reader3]]
  (let [parser (ps/connect-serial-parser
                 {::ps/connect-reader reader}
                 [(pc/resolver `b
                               {::pc/output [:b]}
                               (fn [env input]
                                 {:b (assoc env :keys (keys env))}))])]
    (-> (parser {} [{:>/a [{:b [{:ast [:dispatch-key]}]}]}])
        :>/a 
        :b 
        :ast)))

=> ({:dispatch-key :b} {:dispatch-key :>/a})

does pathom not let you return a set for a to-many join?

i'm seeing a join work when returning a vector, but not for a set

to many joins are always vector

@souenzzo reader3 process is very different from the reader2, and some things will have to work differently

cool, thanks

ahhh i just learned that the env contains the parser 😄 as a relative newcomer to pathom that wasn't obvious.. makes some use cases a lot simpler (or even possible) to implement

This is a bit wordy, but I'm not sure how else to explain it. I have a design where I want to generate some data for a user on the first request for that data, but if they update any of the data I store only the updates (the stored data will be sparse compared to the entire generated data set) A user has a collection of "template" documents. On each request I generate an entity (and it's tree of child properties) in the response for each of the template documents. If the user updates one of the generated entities, then I persist only that entity (with its children). On subsequent requests I will return any existing entities but generate any remaining entities that are in the template list. These are the two main resolvers:

(pc/defresolver user-habit-records-resolver [_ _]
  {::pc/output [{:user/habit-records
                 [{:habit-record/id [:habit-record/id]}]}]})

(pc/defresolver habit-record-resolver [_ _]
  {::pc/input  #{:habit-record/id}
   ::pc/output [:server/message :server/error?
               :habit-record/id
               :habit-record/date
               :habit-record/state
               {:habit-record/habit-id [:habit/id]}
               {:habit-record/task-records [:task-record/id]}]})

Working through the Pathom doc examples and I'm stuck on `defmutation`. I define a mutation as in the docs. I see it's a macro that does ~ `(def ~sym ,,, (fn ~sym ~arg ~@body)`, so I expect it to create a function that returns the body I pass to `defmutation`. But when I run the function, it returns `nil` and I can't identify why. <https://wilkerlucio.github.io/pathom/v2/pathom/2.2.0/connect/connect-mutations.html#_creating_mutations> ```(pc/defmutation send-message [env {:keys [message/text]}] {::pc/sym 'send-message ::pc/params [:message/text] ::pc/output [:messag/id :message/text]} {:message/id 123 :message/text text}) (def my-app-registry [send-message]) (def parser (p/parallel-parser {::p/env {::p/reader [p/map-reader pc/parallel-reader pc/open-ident-reader p/env-placeholder-reader] ::p/placeholder-prefixes #{"&gt;"}} ::p/mutate pc/mutate-async ::p/plugins [(pc/connect-plugin {::pc/register my-app-registry}) p/error-handler-plugin p/request-cache-plugin p/trace-plugin]})) ;; Blows up with "Invalid expression " (&lt;!! (parser {} [(send-message {:message/text "Hello Clojurst!"})])) ;; Returns nil (send-message {:message/text "Hello Clojurst!"})``` Anyone have an idea why? Where am I going astray?

probably just need to quote the symbol:

(<!! (parser {} [(list 'send-message {:message/text "Hello Clojurst!"})]))