@thheller what you mean use the graph api from fulcro?

I mean fulcro like frontend that handles the db normalization

ah, just read the only, currently yeah, but I keep feeling like it would be useful in more contexts

vs. a script of sorts that just one query without any db normalization or so

I was thinking making very trivial ways to create/run parsers

you mean cluncky to call the parser?

no calling the parser is easy. clunky in that I have to unwrap the results and stuff

but its easy enough to handle this with simple helper fns

for the parallel we need to do the channel read, for the sync one are you having to do some post processing too?

not post processing, extracting the data (eg. get the tx-id in the example)

its all fine

cool, just out of curiosity, in which contexts are you using tha parser, like replacing regular logic in the program?

mostly using the parser to answer UI queries/mutations

but also for background tasks on the server directly

I used to do straight db interop on the server but trying to do everything through the parser so its easier to trigger and monitor

makes sense, for those usages I do the same, any operations are first implemented in the parser and then used from it.

but I keep seeing these same patterns in my regular logic, I have some data, it maybe need a few steps to get the data I need, and I keep writing in the regular clojure style, which means I have to remember all the steps

so I wonder what would look like if the parser was a more integral part of my code, delegating all the data transitions to it

yeah treating the parser sort of like a REPL endpoint

I never tried this but is it possible to call transactions in some context?

[{[:foo/ident 123]
  [(foo/do-something {})]}]

instead of [(foo/do-something {:id 123})] and having the tx load the ident?

its technically valid, but I never tried doing it, I saw people doing similar things in GraphQL, I think its an interesting way to do things, could even operate on lists

something like:

[{:customer/all-tags [(customer.tag/delete)]}]

@thheller I did a quick run just for fun, it works already (kind of) 🙂

(pc/defresolver people-resolver [env _]
  {::pc/output [{:people [:person/name]}]}
  {:people [{:person/name "Tom"}
            {:person/name "Tal"}
            {:person/name "Lita"}]})

(pc/defmutation do-something [env input]
  {}
  (println "DO SOMETHING" input (p/entity env))
  {})

(parser {} [{:people [:person/name `(do-something)]}])

DO SOMETHING {} #:person{:name Tom}
DO SOMETHING {} #:person{:name Tal}
DO SOMETHING {} #:person{:name Lita}
=>
{:people [{:person/name "Tom", com.wsscode.pathom.playground/do-something {}}
          {:person/name "Tal", com.wsscode.pathom.playground/do-something {}}
          {:person/name "Lita", com.wsscode.pathom.playground/do-something {}}]}

there is no auto-link between the mutation params and input, you need to grab it from the entity, but that can be easely automated

cool