Om Next - Master Detail props reads

om-tutorial.core.cljs

;; Demonstrating how to deliver props from Root to 3rd level children with om.next
;; [Root] 1---M [Org] 1---M [Group] 1---M [User]

(ns om-tutorial.core
  (:require [goog.dom :as gdom]
            [om.next :as om :refer-macros [defui]]
            [om.dom :as dom]
            [cljs.pprint :refer [pprint]]))

(enable-console-print!)

(println "Hello world!")

(def initdata
  {:orgs [{:o/name "system"
           :o/description "System Organization"
           :o/groups [{:g/name "wheel"
                       :g/description "Wheel Group"
                       :g/users [{:u/name "root"
                                  :u/id 0
                                  :u/password "secret"}
                                 {:u/name "toor"
                                  :u/id -1
                                  :u/password "secret"}]}
                      {:g/name "admin"
                       :g/description "Admin Group"
                       :g/users [{:u/name "ridho"
                                  :u/id 1000
                                  :u/password "secret1"}
                                 {:u/name "nabil"
                                  :u/id 1001
                                  :u/password "secret1"}
                                 {:u/name "daddy"
                                  :u/id 1002
                                  :u/password "secret1"}]}]}]})


(defui User
  static om/Ident
  (ident [this {:keys [u/id]}]
    [:users/by-id id])
  static om/IQuery
  (query [this]
    [:u/name :u/id :u/password])
  Object
  (render [this]
    (dom/div nil
      (dom/div nil "+++<<User>>")
      (dom/div nil (pr-str (om/props this))))))

(def user (om/factory User))

(defui Group
  static om/Ident
  (ident [this {:keys [g/name]}]
    [:groups/by-name name])
  static om/IQuery
  (query [this]
    [:g/name :g/description
     {:g/users (om/get-query User)}])
  Object
  (render [this]
    (let [{:keys [g/users] :as props} (om/props this)
          tree (om/db->tree users {} @(om/get-reconciler this))]
      (dom/div nil
        (dom/div nil "++<<Group>>")
        (dom/div nil (pr-str (om/props this)))
        (apply dom/ol nil
          (map #(dom/li nil (user (get tree %))) users))))))

(def group (om/factory Group))

(defui Org
  static om/Ident
  (ident [this {:keys [o/name]}]
    [:orgs/by-name name])
  static om/IQuery
  (query [this]
    [:o/name :o/description
     {:o/groups (om/get-query Group)}
     ])
  Object
  (render [this]
    (let [{:keys [o/groups] :as props} (om/props this)
          tree (om/db->tree groups {} @(om/get-reconciler this))]
      (dom/div nil
        (dom/div nil "+<<Org>>")
        (dom/div nil (pr-str props))
        (apply dom/ol nil
          (map #(dom/li nil (group (get tree %))) groups))))))

(def org (om/factory Org))

(defui Root
  static om/IQuery
  (query [this]
    [{:orgs (om/get-query Org)}])
  Object
  (render [this]
    (dom/div nil
      (dom/div nil "<<Root>>")
      (dom/div nil (pr-str (om/props this)))
      (apply dom/ol nil
        (map #(dom/li nil (org %)) (:orgs (om/props this)))))))


(defmulti read om/dispatch)

(defmethod read :default
  [{:keys [state] :as env} key params]
  (prn "READ-DEFAULT" key)
  (let [st @state]
    (if-let [[_ v] (find st key)]
      {:value v}
      {:value :not-found})))

(defmethod read :orgs
  [{:keys [state]} key params]
  (prn "READ-ORGS")
  (let [st @state]
    {:value
     (into [] (map #(get-in st %)) (get st key))}))

(def parser
  (om/parser {:read read}))

(def reconciler
  (om/reconciler {:state initdata :parser parser}))

(om/add-root!
  reconciler Root (gdom/getElement "app"))