currentoor: I was trying to think of ways to implement routing, and would need ways to plugin custom read functions for some keywords (not being looked up directly in app state), not sure if this can achieved in untangled

@pedroteixeira what sort of routing? like url routing or app state routing?

@U09FEH8GN sorry, I meant url routing. I think I saw somewhere someone solving on the parser (query would return something conditionally on current route for ex) rather than using union queries on top component. still digging into design patterns here, still unsure on best way to go for current proj with cljs+react. I thought about implementing UntangledApplication, to better underestand Om.next first

@pedroteixeira oh I see, well we bidi with app state to do url routes, our route structure looks like this

(def routes
  ["/"
   {"beta"      :beta/index
    "templates" {"" :templates/index
                 "/"
                 {""                                :templates/index
                  [[keyword :template-type] "/new"] :templates/new}}
    "reports"   :reports/index
    "dashboards/"
    {""                  :dashboards/index
     "new"               :dashboards/new
     [[id+ :id] "/"]
     {""               :dashboards/show
      "copy"           :dashboards/copy
      "edit-schedule/" :dashboards/edit-schedule}
     [[id+ :id] "/edit"] :dashboards/edit}
    ""          [[true :dashboards/index]]}])

then we just store the keyword route value like :dashboard/new in app state and make rendering decisions based on it

then we use pushy to do the url magic

(defn navigate [{:keys [page params replace?] :as route}]
  (if history
    (let [route           (url->route js/location.pathname)
          current-handler (:handler route)
          current-params  (:route-params route)
          navigate*       (if replace? pushy/replace-token! pushy/set-token!)]
      (when (or (not= page current-handler)
                (not= params current-params))
        (navigate* history (route->url page params))))
    (log/warn "History API not available, ignoring route request" route)))

(defn navigate-url [{:keys [url replace?]}]
  (if history
    (let [navigate* (if replace? pushy/replace-token! pushy/set-token!)]
      (when (not= js/location.pathname url)
       (navigate* history url)))
    (log/warn "History API not available, ignoring route request" url)))

(defn mount [comp]
  (when-not history
    (let [update-fn (fn [{v :handler p :route-params :as route}]
                      (let [route-handler               (handlers v)
                            {:keys [mutations post-cb]} (if route-handler
                                                          (route-handler p))
                            route-action                `[(route/update {:page ~v :params ~p})
                                                          (modal/close)]]
                        (om/transact! comp (vec (concat route-action mutations
                                                        [:ui/current-route :ui/modal-open])))
                        (if post-cb (post-cb))))
          listener  (pushy/pushy update-fn url->route)]
     (set! history listener))))

(defn start  []
  (pushy/start! history))

(defn stop []
  (pushy/stop! history))

seems to work well with untangled

thanks for the examples!