use simplified grove rt handling

src/main/shadow/cljs/ui/db/builds.cljs

@@ -4,7 +4,6 @@
     [shadow.grove.events :as ev]
     [shadow.grove.eql-query :as eql]
     [shadow.cljs.model :as m]
-    [shadow.cljs.ui.db.env :as env]
     [shadow.cljs.ui.db.relay-ws :as relay-ws]))
 
 (defn forward-to-ws!

src/main/shadow/cljs/ui/db/inspect.cljs

@@ -5,7 +5,6 @@
     [shadow.grove.db :as db]
     [shadow.grove.eql-query :as eql]
     [shadow.cljs.model :as m]
-    [shadow.cljs.ui.db.env :as env]
     [shadow.cljs.ui.db.relay-ws :as relay-ws]
     )
   (:import [goog.i18n DateTimeFormat]))
@@ -653,6 +652,10 @@
               (update-in [::m/inspect :stack] conj {:type :object-panel :ident object-ident})
               (update-in [::m/inspect :current] inc)))))
 
+    :eval-compile-warnings
+    (do (js/console.log "there were some warnings" call-result)
+        env)
+
     :eval-runtime-error
     (let [{:keys [from ex-oid]} call-result
           object-ident (db/make-ident ::m/object ex-oid)]

src/main/shadow/cljs/ui/db/relay_ws.cljs

@@ -4,11 +4,11 @@
     [shadow.grove.runtime :as rt]
     [shadow.grove.events :as ev]
     [shadow.cljs.model :as m]
-    [shadow.cljs.ui.db.env :as env]
     [clojure.string :as str]))
 
 (defonce rpc-id-seq (atom 0))
 (defonce rpc-ref (atom {}))
+(defonce rt-ref (sg/get-runtime ::m/ui))
 
 (defn relay-welcome
   {::ev/handle ::welcome}
@@ -51,7 +51,7 @@
                               :result-data result-data})
     (cast! env (assoc msg :call-id mid))))
 
-(ev/reg-fx env/rt-ref :relay-send
+(ev/reg-fx rt-ref :relay-send
   (fn [env messages]
     (doseq [msg messages
             :when msg]
@@ -87,13 +87,13 @@
               (let [{:keys [result-data] :as call-data} (get @rpc-ref call-id)]
                 (if (fn? result-data)
                   (result-data msg)
-                  (sg/run-tx! env/rt-ref (assoc result-data :call-result msg))))
+                  (sg/run-tx! rt-ref (assoc result-data :call-result msg))))
 
               (= :ping op)
               (cast! @rt-ref {:op :pong})
 
               :else
-              (sg/run-tx! env/rt-ref
+              (sg/run-tx! rt-ref
                 (if (qualified-keyword? op)
                   (assoc msg :e op)
                   ;; meh, probably shouldn't have used unqualified keywords in shadow.remote?
@@ -108,7 +108,7 @@
 
     (.addEventListener socket "close"
       (fn [e]
-        (sg/run-tx! env/rt-ref {:e ::m/relay-ws-close})
+        (sg/run-tx! rt-ref {:e ::m/relay-ws-close})
         (js/console.log "tool-close" e)))
 
     (.addEventListener socket "error"

src/main/shadow/cljs/ui/main.cljs

@@ -10,7 +10,6 @@
     [shadow.grove.transit :as transit]
     [shadow.grove.http-fx :as http-fx]
     [shadow.cljs.model :as m]
-    [shadow.cljs.ui.db.env :as env]
     [shadow.cljs.ui.db.relay-ws :as relay-ws]
     [shadow.cljs.ui.db.generic]
     [shadow.cljs.ui.db.builds]
@@ -170,17 +169,21 @@
           [:div "Loading ..."]])}
     (ui-root*)))
 
-(defonce root-el (js/document.getElementById "root"))
+(defonce root-el
+  (js/document.getElementById "root"))
+
+(def rt-ref
+  (sg/get-runtime ::m/ui))
 
 (defn start []
-  (sg/render env/rt-ref root-el (ui-root)))
+  (sg/render rt-ref root-el (ui-root)))
 
 ;; macro magic requires this ns always being recompiled
 ;; not yet possible to hide this, maybe a build-hook would be better than a macro?
 ;; experimenting with use metadata to configure app, might also be more useful
 ;; for documentation purposes or tooling.
 (defn register-events! []
-  (ev/register-events! env/rt-ref))
+  (ev/register-events! rt-ref))
 
 (defn ^:dev/after-load reload []
   (register-events!)
@@ -191,49 +194,91 @@
       (.-content)))
 
 (defn init []
+
+  (sg/add-db-type rt-ref ::m/runtime
+    {:primary-key :runtime-id})
+
+  (sg/add-db-type rt-ref ::m/error
+    {:primary-key :error-id})
+
+  (sg/add-db-type rt-ref ::m/object
+    {:primary-key :oid
+     :joins {::m/runtime [:one ::m/runtime]}})
+
+  (sg/add-db-type rt-ref ::m/http-server
+    {:primary-key ::m/http-server-id})
+
+  (sg/add-db-type rt-ref ::m/build
+    {:type :entity
+     :primary-key ::m/build-id})
+
+  (sg/add-db-type rt-ref ::m/database
+    {:primary-key :db-id
+     :joins {::m/runtime [:one ::m/runtime]}})
+
+  (sg/add-db-type rt-ref ::m/runtime-ns
+    {:primary-key [::m/runtime :ns]
+     :joins {::m/runtime [:one ::m/runtime]}})
+
+  (sg/add-db-type rt-ref ::m/runtime-var
+    {:primary-key [::m/runtime :var]
+     :joins {::m/runtime [:one ::m/runtime]
+             ::m/runtime-ns [:one ::m/runtime-ns]}})
+
+  (sg/db-init
+    rt-ref
+    (fn [db]
+      {::m/current-page :db/loading
+       ::m/builds :db/loading
+       ::m/http-servers :db/loading
+       ::m/init-complete? :db/loading ;; used a marker for initial suspense
+       ;; assume that the first connect will succeed
+       ;; otherwise shows disconnect banner for a few ms on startup
+       ::m/relay-ws-connected true
+       ::m/ui-options {} ;; FIXME: should probably store this somewhere on the client side too
+       ::m/runtimes []
+       ::m/active-builds []
+       ::m/tap-stream (list)
+       ::m/tap-latest nil
+       ::m/inspect
+       {:current 0
+        :stack
+        [{:type :tap-panel}]}}))
+
   ;; needs to be called before start since otherwise we can't process events triggered by any of these
   (register-events!)
 
-  (transit/init! env/rt-ref)
-
-  (when ^boolean js/goog.DEBUG
-    (swap! env/rt-ref assoc :shadow.grove.runtime/tx-reporter
-      (fn [report]
-        (let [e (-> report :event :e)]
-          (case e
-            ::m/relay-ws
-            (js/console.log "[WS]" (-> report :event :msg :op) (-> report :event :msg) report)
-            (js/console.log e report))))))
+  (transit/init! rt-ref)
 
-  (history/init! env/rt-ref
+  (history/init! rt-ref
     {:start-token "/dashboard"
      :root-el root-el})
 
-  (sg/reg-fx env/rt-ref :http-api
+  (sg/reg-fx rt-ref :http-api
     (http-fx/make-handler
       {:on-error {:e ::m/request-error!}
        :base-url "/api"
        :request-format :transit}))
 
-  (relay-ws/init env/rt-ref server-token
+  (relay-ws/init rt-ref server-token
     (fn []
-      (relay-ws/cast! @env/rt-ref
+      (relay-ws/cast! @rt-ref
         {:op ::m/load-ui-options
          :to 1 ;; FIXME: don't blindly assume CLJ runtime is 1
          })
 
       ;; builds starting, stopping
-      (relay-ws/cast! @env/rt-ref
+      (relay-ws/cast! @rt-ref
         {:op ::m/subscribe
          :to 1 ;; FIXME: don't blindly assume CLJ runtime is 1
          ::m/topic ::m/supervisor})
 
       ;; build progress, errors, success
-      (relay-ws/cast! @env/rt-ref
+      (relay-ws/cast! @rt-ref
         {:op ::m/subscribe
          :to 1 ;; FIXME: don't blindly assume CLJ runtime is 1
          ::m/topic ::m/build-status-update})))
 
-  (sg/run-tx! env/rt-ref {:e ::m/init!})
+  (sg/run-tx! rt-ref {:e ::m/init!})
 
-  (js/setTimeout start 0))
+  (start))