can someone help me with creating “routing” system, when components dynamically get rendered in content area based on selected item in the menu?

I have App component (root), I have Content component, that would be dynamically rendering other components. So I do have to have a join query for the Content in the App’s IQuery?

let’s say I have something like this:

[ {:app/current-route [:app/current-route}
  {:app/current-data (om/subquery this subq-ref subq-class)}]

now I have to have read method that dispatches on :app/current-data?

I think I’m totally lost here

I’m doing something similar where I run my parser manually, but I’m struggling to get remote execution

https://gist.github.com/hkjels/ec2bfa514e9c17291d9b11ef3cf76785 Here’s the gist of it

Using Om now can’t I call transact on a cursor I get from get-state? I get the error “Uncaught Error: Assert failed: (transactable? cursor)"

@hkjels: {:remote true} I’m not sure about this? shouldn’t you be sending ast to remote?

I believe {:remote true} is short for sending the AST without modifications

Each individual component works if I mount them as root, so the problem only occurs when I move the query onto the root-component using set-query!

@ag: https://github.com/iwanKaramazow/om-router

@iwankaramazow: oh cool, thanks

How can I make component local state change percolate upwards?

so I’m getting

No queries exist for component path

@ag: that error is not about setting query in a lifecycle method

it’s exactly what it says, there are no queries along the path of the components it lists

i.e. queries don’t correctly compose

happy to help you figure out what’s wrong if you post the defui declarations of the components involved with just their IQuery implementations

I’m struggling to dynamically bind a component to another component 😞

I think it something with queries and stuff

so I have a component that when added to the root works fine

now I need dynamically render different components in a another container component

using set-query! it sets the query, but I’m struggling to send right AST to the server

damn it, I can even explain it right

so I have a tree of components let’s call them MyTree (when added to the root MyTree works just fine), now instead of that, I need to dynamically render different components (including MyTree), but now in whatever my root component would be (let’s call it App) I need to join a query, {:app/current-data [:app/current-data]} which would be empty at first, but then at some point in Content (which is child of App and container for other components, including MyTree) I set-query! and then it would trigger dispatch of read :app/current-data, there I need to grab part of the query of MyTree (of which the query itself is composed) and send it ast of that query the server. But AST somehow is different (compared to what it is when MyTree is directly added to root) and so fetching data fails

right but that is an entirely different problem

which is not related to the error you’re getting when setting the query

yeah, I got that…

so my query in read dispatch now looks like something like this:

[{:app/current-data [{:my-tree/resources [:id :description :account-type :account-item-data]} {:my-tree/requirements [:id :description :account-type :account-item-data]} }]}]

I need to cut off :app/current-data of that (since I’m interested in :my-tree stuff only) make query->ast and send it to the server

or do somehow trigger read methods of :my-tree/resources and :my-tree/requirements

there’s e.g. process-roots

or you can roll your own

probably better to manipulate the query in the send method

hold on… I think I got somewhere here

nah, it didn’t work

every time when I feel I grasped something, next minute I feel completely lost

@urbanslug: get-state doesn’t return a cursor

Yeah, it returns component local state.

I have this issue where I change component local state for a “pop up/modal” but when closed and reopened it goes back to its old state.

I’m thinking of fixing it in something like IShouldUpdate

or similar functions, gotta read the docs more.

@dnolen: ^

maybe not -> “You should only implement this if you really know what you're doing. Even then you probably shouldn't."

you should be familiar with life cycle method yes

IShouldUpdate is an exception because you have to be careful

that is you need to replicate everything the default implementation does

Yeah I got that from the wiki.

Just the stern warning 🙂

—> “IWillReceiveProps"

I wrote this test that demonstrates my issue with process-roots.

(deftest test-process-roots-recursive-non-query-root
  (let [p (om/parser {:read precise-read})
        m (om/process-roots
            (p {:state (atom {})}
              '[{:fake/key [{:real/key ...}]} {:other/key [:other/key {:other/key ...}]}] :remote))]
    (is (= [{:real/key '...} {:other/key [:other/key {:other/key '...}]}] (:query m)))))

When the recursive query isn't under a fake root, it throws #object[Error Error: ... is not ISeqable]

is it always expected that given query round-tripping to om/query->ast->`om/ast->query` would return the initial query? I think I’m seeing somewhat different

I would assume that to be true. Or at least, I would assume that two round trips will give you the same result as one round trip.

I have a query that looks like this:

{:app/current-data (om/subquery this sub-ref sub-class)}

[{:ledger/resources [:id :description :account-type :account-item-data]}
            {:ledger/requirements [:id :description :account-type :account-item-data]}]

when I send it, on the server it wants me to have a dispatch for [:ledger/resources [:id :description :account-type :account-item-data], why it’s not triggering read :ledger/resources?

@ag: in your send function, flatten the query like this: (into [] (flatten (:remote remotes)))

(or just send the first element of (:remote remotes)

the “why" is here: https://github.com/omcljs/om/blob/master/src/main/om/next/impl/parser.cljc#L262-L263

this is my send, I’ve copied it from Malcolm Sparks’s tutorial:

(defn send [m cb]
  (let [xhr          (new js/XMLHttpRequest)
        request-body (transit/write (transit/writer :json) m)]
    (.open xhr "POST" "/ledger-data")
    (.setRequestHeader xhr "Content-Type" "application/transit+json")
    (.setRequestHeader xhr "Accept" "application/transit+json")
    (.addEventListener
      xhr "load"
      (fn [evt]
        (let [response (transit/read (transit/reader :json)
                         (.. evt -currentTarget -responseText))]
          (cb response))))
    (.send xhr request-body)))

right, so s/remotes/m

eh.. didn’t get it

@ag: it seems you’re sending the whole remotes map to the server

I meant you need to get at the first element of the query that is probably under the key :remote

oh yeah… ok

but then it’s not returning anything :[

it’s still trying to dispatch on the whole thing

{:ledger/requirements [:id :description :account-type :account-item-data]}

I don’t have dispatch for that, I have for :ledger/requirements

sounds unlikely

if you changed it and it’s behaving the same

this is how m looks like {:remote [{:ledger/resources [:id :description :account-type :account-item-data]} {:ledger/requirements [:id :description :account-type :account-item-data]}]} and it works perfectly when I have the component as a root

but if I try to make it a child of another component it stops

is it possible that query->ast doesn’t work correctly for join queries? such as

[{:ledger/resources [:id :description :account-type :account-item-data]}
            {:ledger/requiremenkts [:id :description :account-type :account-item-data]}]

or am I missing something?