https://github.com/fulcrologic/fulcro-rad-template/blob/main/src/dev/development.clj

I don't know. What you describe sounds pretty OK to me.

I think a load is what I’d use, on the click of the row, not as a query inclusion. Well, more precisely, I’d include :ui/chart-data in the row query inclusion. That won’t be sent to the server, so you won’t get data for it. Then on row click load your data and target it at the :ui/chart-data The row will have an ident (you get row props, so you can make it from that). If you’ve already got a resolver that can start from that ident and get to your chart data, you could load that with something like:

(df/load! this row-ident (rc/nc [:row/id :row/field])
  {:params {:target (conj row-ident :ui/chart-data)})

These are just Fulcro components running a state machine…so, the normal Fulcro patterns still apply.

I'm having a bit of trouble getting this to work. Where ro/row-pk foo/id, I presume the row's ident is like [:foo/id 1]? When I try it like that, the target ends up with that same ident as its value, and the row-inclusion isn't found. I must be getting the ident wrong, but not sure how..?

and 1 is the ID of the row, and you ahve a pathom resolver that can go from that kind of ID to the desired chart results?

input :foo/id output :foo/chart-results

that kind of thing

Yep:

ao/pc-input #{::id}
   ao/pc-output [::chart-results]

and that is installed and verified to be working (e.g. from the EQL tab you can send [{[:foo/id 1] [:foo/chart-results]}] and get the data?

If you run that load manually from the REPL you should see the chart results merge into the db

then it’s a matter of making sure targeting puts them under :ui/chart-results…oh…they are not normalized, but it still should work…but I’d verify the database looks right from a manual invocation

ro/on-select-row (fn [report-instance {::foo/keys [id] :as row-props}]
                      (tap> row-props)
                      (let [row-ident [::foo/id id]
                            target [::foo/id id :ui/chart-data]]
                       (df/load! report-instance
                                row-ident
                                (rc/nc [::foo/id ::foo/chart-results])
                                {:params {:group-by :month}
                                 :target target})))}

:foo/id
 {#uuid "ffffffff-ffff-ffff-ffff-000000000002"
  {:foo/id
   #uuid "ffffffff-ffff-ffff-ffff-000000000002",
   :foo/chart-results
   [{:period "2009-08-01", :count 4}
    {:period "2009-09-01", :count 4}]
   :ui/chart-results
   [:foo/id
    #uuid "ffffffff-ffff-ffff-ffff-000000000002"]},

Maybe it's this part? > When loading an entity (by ident), then this option will place additional idents at the target path(s) that point to that entity.

oh crap

my bad

you loaded the ident…targeting won’t work on that…use a post-action 😛

it will auto-normalize and merge without targeting, it’ll just be at the “wrong key” for the UI to see it

so you just need to “move it” from the I/O key (::chart-results) to the one in the row’s query (:ui/chart-results)

we don’t want ::chart-results in the UI query becaue that would cause the initial report to load it

(I don’t have support for :without in the report state machine, or that would have actually done it)

so instead of target, use :post-action (fn [{:keys [state]}] (swap! state ...)

No worries 🙂 That makes sense. I hadn't thought of the approach of using a :ui/ key to avoid loading the data at all and the rc/nc function is something I had wanted but never came across in the docs. My plan was to use a query-only component this morning, until I read your tip.

So, load! is designed for this use-case. There is a param called :without #{::chart-results} that will elide the real thing from the query, and then you can use load-field! to populate just one thing…but RAD reports don’t give you access to that

thus this “workaround”

You could easily “derive” a new state machine definition that gave you access to the load params, and then you could just put the real thing in the query

I guess it would be a reasonable option to add to reports in general

Yes, a sort of deferred per-row field loading you could call it, I guess. Seems like expanding row data on click or some other action could be a common operation.

It is, that’s why core Fulcro has a mechanism for it 😄

just didn’t give a hook for it in RAD yet

RAD is sweet. Obviously I'm still building up my confidence with it and the lib is evolving but the shortcuts I do get out of it are very nice.

Thanks for your help as always!

@U0CKQ19AQ so I saw you added https://github.com/fulcrologic/fulcro-rad/commit/9fcfe05c7a16776f998d8a1edac290f4d5c92af3 and I'm trying to update my code to use it. It seems it's not as straight forward as I thought, because load-field requires a component instance and it doesn't look like there's an easy way to get at a generated row instance (BodyItem). I'm calling it like (df/load-field! report-instance ::chart-data) and it ends up doing the join on [::report/id ::MyReport], which understandably doesn't work correctly. Am I missing something?

Yes, you need to write a BodyItem of your own, so you can put your load field there

ro/BodyItem option

Got it, thank you 🙏