simple example with all the sub-queries spelled out instead of hierarchically derived (have the latter, too):

(re-frame/reg-event-fx
  ::start
  interceptors
  (fn-traced [{:keys [db]} [_ code]]
    {:db db/default-db
     ::dfr/fetch {:remote :default
                  :target {:op     :replace
                           :target [:ui/set :set]}
                  :marker [:ui/set :loading?]
                  :query [{[:set/code code]
                           [:set/id :set/code :set/name :set/type :block/code
                            :block/name :set/card-count :set/released-at :set/icon-svg
                            {:set/prints
                             (df/query entity/Print
                                       [:print/id
                                        :print/collector-number
                                        :gatherer/uri
                                        :gatherer/image-uri
                                        {:>/card (df/query entity/Card
                                                           [:card/id
                                                            :card/name
                                                            :card/color-identity
                                                            :scryfall/image-uris
                                                            {:card/inventory (df/query entity/Inventory
                                                                                       [:inventory/qty
                                                                                        :print/id])}
                                                            {:card/faces [:card.face/id
                                                                          :card.face/name
                                                                          :card/supertypes
                                                                          :card/types
                                                                          :card/type-line
                                                                          :gatherer/image-uri
                                                                          :card/oracle-text]}])}
                                        {:>/inventory (df/query entity/Inventory
                                                                [:print/id
                                                                 :inventory/qty])}
                                        ])}]}]}}))

The only thing df/query does there is (with-meta ...)

when the data comes back, the normalization engine just checks the metadata attached to the original query, and normalizes accordingly

I think that's also pretty similar to what fulcro does internally

thanks, that helps

so it looks like you annotate each level of query with an “entity” that allows you to associate the ident info

yea, pretty much - the stuff I want normalized gets annotated

each "entity" is just a map, effectively, with info on how to normalize (where to in the database, and which field is the ID), as well as a list of all query-able fields, for convenience, if you just want to grab everything

have you attempted to integrate anything with spec yet?

not on the query-side, no; no plans to do so either (not obvious to me where the benefit is?); I do use spec for validation of mutations, though

just checking

we have a lot of specs right now of all our domain entities. it feels like a great extension to those to specify some normalization behavior

it makes sense why you wouldn’t care as much if you already had these descriptions with normalization without specs. I just already have them, and don’t want to write the same thing twice 😛

fair