datascript -> rum/render -> should-update about rum HOT 4 CLOSED

Old and new are states of component. In simplest case, it you’re not using anything fancy, state just contains arguments this component was created with ({:rum/args args}). By comparing args it was created before and args it is created now, you can decide if you need to update.

Simple way to solve your problem is to call component with query result as argument:

(comp (ds/q ...))

and use rum/static mixin which does exactly that: compares old arguments value with new arguments value.

Did I answered your question?

from rum.

Here's how I did it so far. The calling component passes an entity, not query result. The reason is I needed the entity as well. It seemed logic to me to pass the entity only, since that would/should be enough:

(rum/defc stagelist []
    [:section 
      (let [q (->> (ds/q '[:find ?e ?o  :where [?e :stage/order ?o]  [?e :stage/name ?n]] @conn)
        (sort-by second))]   
      (map #(stage (ds/entity @conn (first %))) q))]) 

The component that's being called (the one with the query):

(rum/defc stage [ent]  
    (let [n (name (:stage/name ent))
          id (:db/id ent) 
          q (ds/q `[:find [?e ...] :where [?e :item/stage ~id]] @conn)]   
    ... ))

The passed entity itself is not changing, but the result of the query is. I didn't add any mixin in this example. I nest and use this kind of 'pass entity and perform a query' rather often, or at least, I would like to. Since the query is something 'component specific', I'd rather keep in in the component, not in the caller. This way, it makes the code easier to reason about imo - the query is bounded to the component.

from rum.

Well, there’s no way around it. If you want to avoid unnecessary rendering you need a component with a lifecycle around the place. In your case you probably need second component that accepts query result and implements shouldComponentUpdate. Then just include that component inside stage:

(rum/defc stage-inner < rum/static [q n]
  ...)

(rum/defc stage [ent]  
  (let [n  (name (:stage/name ent))
        id (:db/id ent) 
        q  (ds/q `[:find [?e ...] :where [?e :item/stage ~id]] @conn)]
    (stage-inner q n)))

Remember that you’re not avoiding query. You only avoiding rendering of stage-inner. Worth it only if rendering is expensive.

from rum.

Right, I started to realize that :). Of course, the query can't be avoided, rendering can... which was my goal (just to get a hang of rum). I rather like the inner component idea. It's simple, and logic. It'll be pretty easy to make a function or macro to generate both, and possibly adding some functionality in the outer/wrapper component.

Great, thx a lot!

from rum.