@tony.kay hello, using Fulcro 3, I'm trying to wrap my network so I get pathom traces during development, but I can't figure how to make that work... I tried using a request middleware

(fulcro-http/fulcro-http-remote
  {:url                ""
   :request-middleware (let [wrapper (fulcro-http/wrap-fulcro-request)]
                         (fn [req]
                           (let [req' (update req :body conj :com.wsscode.pathom/trace)]
                             (wrapper req'))))})

(let [remote (fulcro-http/fulcro-http-remote
               {:url ""})]
  {:transmit! (fn [x req]
                (let [req' (update-in req [::txn/ast :children] conj {:type :prop
                                                                      :key  :com.wsscode.pathom/trace
                                                                      :key  :com.wsscode.pathom/trace})]
                  ((:transmit! remote) remote req')))})

but the source seems to never get modified in Inspect

is there a way to make this affect the inspect so the request goes with trace?

@wilkerlucio So, Inspect is sent messages from the tx processing separate from the low-level networking

try the global-eql-transform option to the app itself. I think that is applied before it reaches that layer

I can have a look tomorrow if that doesn’t work

@tony.kay thanks, I just tried, seems like the trace is correctly add to the query, but for some reason the response is not picking up

if I get the same query and use Send to query and then send from there, it works

I guess maybe the response merge is not considering the modified query

hm. could be a bug. I’m mainly using it to strip things, not add them

data fetch ns has the logic…it’s all in the load mutation implementation

in data_fetch.cljc

finish-load!

which uses the query that it got from the generated load params

which uses update-query, which in turn defaults to global-eql-transform

so, are you using both? That would mess with it

oh…actually

there is a bug I think

line 266…I accidentally made two transforms

:query-transform-default is used as the default for load…`global-eql-transform` is at the network layer

I think that might have been intentional now that I’m revisiting it. The former is for changing queries for loads, and the other is for doing “behind the scenes” augments nearer the network layer (which can include messing with mutations)

but only the former would be seen as part of merge

This particular concern: getting trace data to inspect…I think we need an addl “event” that sends that to inspect

I don’t want that merged with state (by tooling)

Much better to put something at the network layer that asks for it (which is what you just did) and something else that looks for it in the response and sends an event to inspect

yeah, there are pros and cons on having it on state, I think it helps with clarify when its part of the DB, being nothing special, this allows debugging the data from the trace if needed so

I just tried using :query-transform-default, but no effect there

as a (conj query ::pathom/trace)?

ok, that is a bug…I think I see it…just a min. These corner case things get used so rarely 😜

no…take that back…it looks fine

But in any case: I see the pathom trace as a pure tooling issue, not something for the client application layer (unless the app layer itself is implementing trace viewing). Therefore, there is no reason you should have to configure it at all (other than to have Inspect open and attached to the application, and perhaps a “show trace” option enabled).

So, I’d say we should add an addl hook that lets Inspect turn on/off tracing (which sends that message to the app), and then logic at the network layer that adds in the query bit and pulls off the trace result to send to inspect.

(we can delay the toggle until later if we want, and make it purely an app config option)

Hey, is @currentoor's Fulcro presentation from Clojure South available anywhere on the internet yet? It was announced here on slack earlier and I wouldn't want to miss it. 😊