enhance(rtc): support show block-rtc-log for dev

src/main/frontend/components/content.cljs

@@ -1,37 +1,40 @@
 (ns frontend.components.content
-  (:require [clojure.string :as string]
+  (:require [cljs-bean.core :as bean]
+            [cljs-time.coerce :as tc]
+            [cljs.pprint :as pp]
+            [clojure.string :as string]
+            [cognitect.transit :as transit]
             [dommy.core :as d]
             [frontend.commands :as commands]
             [frontend.components.editor :as editor]
-            [frontend.components.page-menu :as page-menu]
             [frontend.components.export :as export]
+            [frontend.components.page-menu :as page-menu]
+            [frontend.config :as config]
             [frontend.context.i18n :refer [t]]
             [frontend.db :as db]
             [frontend.extensions.srs :as srs]
             [frontend.handler.common :as common-handler]
+            [frontend.handler.common.developer :as dev-common-handler]
             [frontend.handler.editor :as editor-handler]
             [frontend.handler.notification :as notification]
             [frontend.handler.page :as page-handler]
-            [frontend.handler.common.developer :as dev-common-handler]
             [frontend.handler.property :as property-handler]
             [frontend.handler.property.util :as pu]
             [frontend.mixins :as mixins]
+            [frontend.modules.shortcut.core :as shortcut]
+            [frontend.persist-db.browser :as db-browser]
             [frontend.state :as state]
             [frontend.ui :as ui]
             [frontend.util :as util]
-            [frontend.modules.shortcut.core :as shortcut]
-            [logseq.common.util :as common-util]
-            [logseq.common.util.block-ref :as block-ref]
             [frontend.util.url :as url-util]
             [goog.dom :as gdom]
             [goog.object :as gobj]
-            [rum.core :as rum]
-            [frontend.config :as config]
-            [cljs.pprint :as pp]
-            [cljs-time.coerce :as tc]
+            [logseq.common.util :as common-util]
+            [logseq.common.util.block-ref :as block-ref]
             [promesa.core :as p]
-            [cljs-bean.core :as bean]
-            [frontend.persist-db.browser :as db-browser]))
+            [rum.core :as rum]))
+
+(defonce transit-r (transit/reader :json))
 
 ;; TODO i18n support
 
@@ -325,7 +328,18 @@
                                              :content (:value version)})
                                           versions))))))}
 
-            "(Dev) Show block content history"))]))))
+            "(Dev) Show block content history"))
+         (when (state/sub [:ui/developer-mode?])
+           (ui/menu-link
+            {:key "(Dev) Show block RTC log"
+             :on-click
+             (fn []
+               (let [^object worker @db-browser/*worker]
+                 (p/let [result (.rtc-get-block-update-log worker (str block-id))
+                         log (transit/read transit-r result)]
+                   (prn :Dev-show-block-RTC-log block-id)
+                   (pp/pprint log))))}
+            "(Dev) Show block RTC log"))]))))
 
 (rum/defc block-ref-custom-context-menu-content
   [block block-ref-id]

src/main/frontend/db_worker.cljs

@@ -1,31 +1,32 @@
 (ns frontend.db-worker
   "Worker used for browser DB implementation"
-  (:require [promesa.core :as p]
-            [datascript.storage :refer [IStorage]]
-            [clojure.edn :as edn]
-            [datascript.core :as d]
-            [logseq.db.sqlite.common-db :as sqlite-common-db]
-            [shadow.cljs.modern :refer [defclass]]
-            ["@logseq/sqlite-wasm" :default sqlite3InitModule]
+  (:require ["@logseq/sqlite-wasm" :default sqlite3InitModule]
             ["comlink" :as Comlink]
-            [clojure.string :as string]
             [cljs-bean.core :as bean]
-            [frontend.worker.search :as search]
-            [logseq.db.sqlite.util :as sqlite-util]
-            [frontend.worker.state :as worker-state]
-            [frontend.worker.file :as file]
+            [clojure.core.async :as async]
+            [clojure.edn :as edn]
+            [clojure.string :as string]
+            [cognitect.transit :as transit]
+            [datascript.core :as d]
+            [datascript.storage :refer [IStorage]]
+            [frontend.worker.async-util :include-macros true :refer [<?]]
             [frontend.worker.export :as worker-export]
-            [logseq.db :as ldb]
-            [frontend.worker.rtc.op-mem-layer :as op-mem-layer]
+            [frontend.worker.file :as file]
+            [frontend.worker.handler.page :as worker-page]
+            [frontend.worker.handler.page.rename :as worker-page-rename]
+            [frontend.worker.rtc.core :as rtc-core]
             [frontend.worker.rtc.db-listener :as rtc-db-listener]
             [frontend.worker.rtc.full-upload-download-graph :as rtc-updown]
-            [frontend.worker.rtc.core :as rtc-core]
-            [clojure.core.async :as async]
-            [frontend.worker.async-util :include-macros true :refer [<?]]
+            [frontend.worker.rtc.op-mem-layer :as op-mem-layer]
+            [frontend.worker.search :as search]
+            [frontend.worker.state :as worker-state]
             [frontend.worker.util :as worker-util]
-            [frontend.worker.handler.page.rename :as worker-page-rename]
-            [frontend.worker.handler.page :as worker-page]
-            [logseq.outliner.op :as outliner-op]))
+            [logseq.db :as ldb]
+            [logseq.db.sqlite.common-db :as sqlite-common-db]
+            [logseq.db.sqlite.util :as sqlite-util]
+            [logseq.outliner.op :as outliner-op]
+            [promesa.core :as p]
+            [shadow.cljs.modern :refer [defclass]]))
 
 (defonce *sqlite worker-state/*sqlite)
 (defonce *sqlite-conns worker-state/*sqlite-conns)
@@ -33,6 +34,8 @@
 (defonce *opfs-pools worker-state/*opfs-pools)
 (defonce *publishing? (atom false))
 
+(defonce transit-w (transit/writer :json))
+
 (defn- get-pool-name
   [graph-name]
   (str "logseq-pool-" (sqlite-common-db/sanitize-db-name graph-name)))
@@ -621,6 +624,10 @@
    [_this repo]
    (bean/->js (rtc-core/get-debug-state repo)))
 
+  (rtc-get-block-update-log
+   [_this block-uuid]
+   (transit/write transit-w (rtc-core/get-block-update-log (uuid block-uuid))))
+
   (keep-alive
    [_this]
    "alive")

src/main/frontend/worker/rtc/core.cljs

@@ -54,16 +54,18 @@
 
 (def state-schema
   "
-  | :*graph-uuid                      | atom of graph-uuid syncing now                     |
-  | :*repo                            | atom of repo name syncing now                      |
-  | :data-from-ws-chan                | channel for receive messages from server websocket |
-  | :data-from-ws-pub                 | pub of :data-from-ws-chan, dispatch by :req-id     |
-  | :*stop-rtc-loop-chan              | atom of chan to stop <loop-for-rtc                 |
-  | :*ws                              | atom of websocket                                  |
-  | :*rtc-state                       | atom of state of current rtc progress              |
-  | :toggle-auto-push-client-ops-chan | channel to toggle pushing client ops automatically |
-  | :*auto-push-client-ops?           | atom to show if it's push client-ops automatically |
-  | :force-push-client-ops-chan       | chan used to force push client-ops                 |
+  | :*graph-uuid                      | atom of graph-uuid syncing now                           |
+  | :*repo                            | atom of repo name syncing now                            |
+  | :data-from-ws-chan                | channel for receive messages from server websocket       |
+  | :data-from-ws-pub                 | pub of :data-from-ws-chan, dispatch by :req-id           |
+  | :*stop-rtc-loop-chan              | atom of chan to stop <loop-for-rtc                       |
+  | :*ws                              | atom of websocket                                        |
+  | :*rtc-state                       | atom of state of current rtc progress                    |
+  | :toggle-auto-push-client-ops-chan | channel to toggle pushing client ops automatically       |
+  | :*auto-push-client-ops?           | atom to show if it's push client-ops automatically       |
+  | :force-push-client-ops-chan       | chan used to force push client-ops                       |
+  | :dev-mode?                        | when not nil, will update :block-update-log              |
+  | :block-update-log                 | map of block-uuid-> coll of local-op and remote-updates  |
 "
   [:map {:closed true}
    [:*graph-uuid :any]
@@ -80,7 +82,8 @@
    [:*auto-push-client-ops? :any]
    [:force-push-client-ops-chan :any]
    [:counter :any]
-   [:dev-mode? :boolean]])
+   [:dev-mode? :boolean]
+   [:*block-update-log :any]])
 
 (def state-validator
   (let [validator (m/validator state-schema)]
@@ -93,6 +96,18 @@
   [:enum :open :closed])
 (def rtc-state-validator (m/validator rtc-state-schema))
 
+(defn- update-log
+  [state {:keys [local-ops remote-update-map]}]
+  (when (:dev-mode? state)
+    (let [*block-update-log (:*block-update-log state)]
+      (doseq [op local-ops]
+        (when-let [block-uuid (:block-uuid (second op))]
+          (swap! *block-update-log update block-uuid (fnil conj []) op)))
+      (doseq [[block-uuid value] remote-update-map]
+        (swap! *block-update-log update block-uuid (fnil conj []) value)))))
+
+
+
 (def transit-w (transit/writer :json))
 (def transit-r (transit/reader :json))
 
@@ -778,7 +793,8 @@
           date-formatter @(:*date-formatter state)]
       (op-mem-layer/new-branch! repo)
       (try
-        (let [ops-for-remote (sort-remote-ops (gen-block-uuid->remote-ops repo conn))
+        (let [ops-for-remote (rtc-const/to-ws-ops-decoder
+                              (sort-remote-ops (gen-block-uuid->remote-ops repo conn)))
               local-tx (op-mem-layer/get-local-tx repo)
               r (<? (ws/<send&receive state {:action "apply-ops" :graph-uuid @(:*graph-uuid state)
                                              :ops ops-for-remote :t-before (or local-tx 1)}))]
@@ -806,6 +822,7 @@
                   (throw (ex-info "Unavailable" {:remote-ex remote-ex}))))
             (do (assert (pos? (:t r)) r)
                 (op-mem-layer/commit! repo)
+                (update-log state {:local-ops ops-for-remote})
                 (<! (<apply-remote-data repo conn date-formatter r))
                 (prn :<client-op-update-handler :t (:t r)))))
         (catch :default e
@@ -948,9 +965,10 @@
    :*stop-rtc-loop-chan (atom nil)
    :force-push-client-ops-chan (chan (async/sliding-buffer 1))
    :*ws (atom ws)
-   :dev-mode? dev-mode?
    ;; used to trigger state watch
-   :counter 0})
+   :counter 0
+   :dev-mode? dev-mode?
+   :*block-update-log (atom {})})
 
 (defn get-debug-state
   ([repo]
@@ -960,15 +978,23 @@
          local-tx (op-mem-layer/get-local-tx repo)
          unpushed-block-update-count (op-mem-layer/get-unpushed-block-update-count repo)]
      (cond->
-      {:graph-uuid graph-uuid
-       :local-tx local-tx
-       :unpushed-block-update-count unpushed-block-update-count}
-       state
-       (merge
-        {:rtc-state @(:*rtc-state state)
-         :ws-state (some-> @(:*ws state) ws/get-state)
-         :auto-push-updates? (when-let [a (:*auto-push-client-ops? state)]
-                               @a)})))))
+         {:graph-uuid graph-uuid
+          :local-tx local-tx
+          :unpushed-block-update-count unpushed-block-update-count}
+         state
+         (merge
+          {:rtc-state @(:*rtc-state state)
+           :ws-state (some-> @(:*ws state) ws/get-state)
+           :auto-push-updates? (when-let [a (:*auto-push-client-ops? state)]
+                                 @a)})))))
+
+(defn get-block-update-log
+  ([block-uuid]
+   (get-block-update-log @*state block-uuid))
+  ([state block-uuid]
+   (when-let [*block-update-log (:*block-update-log state)]
+     (@*block-update-log block-uuid))))
+
 
 ;; FIXME: token might be expired
 (defn <init-state