use indexeddb to store rtc-ops

src/electron/electron/handler.cljs

@@ -33,8 +33,7 @@
             [logseq.db.sqlite.db :as sqlite-db]
             [logseq.db.sqlite.util :as sqlite-util]
             [logseq.common.graph :as common-graph]
-            [promesa.core :as p]
-            [electron.rtc-handler]))
+            [promesa.core :as p]))
 
 (defmethod handle :mkdir [_window [_ dir]]
   (fs/mkdirSync dir))

src/electron/electron/rtc_handler.cljs

@@ -1,20 +0,0 @@
-(ns electron.rtc-handler
-  (:require [electron.handler-interface :refer [handle]]
-            [electron.db :as db]
-            [cljs.reader :as reader]
-            [logseq.db.sqlite.rtc :as sqlite-rtc]))
-
-(defmethod handle :rtc/init [_window [_ repo]]
-  (sqlite-rtc/init! (db/get-graphs-dir) repo))
-
-(defmethod handle :rtc/add-ops [_window [_ repo data-str]]
-  (let [ops (reader/read-string data-str)]
-    (when (seq ops)
-      (sqlite-rtc/add-ops! repo ops))))
-
-
-(defmethod handle :rtc/get-ops&local-tx [_window [_ repo]]
-  (sqlite-rtc/get-ops&local-tx repo))
-
-(defmethod handle :rtc/clean-ops [_window [_ repo]]
-  (sqlite-rtc/clean-ops! repo))

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

@@ -18,10 +18,6 @@
             [frontend.db.rtc.op :as op]))
 
 
-(defn init-rtc-op-db
-  [repo]
-  (when (config/db-based-graph? repo)
-    (ipc/ipc :rtc/init repo)))
 
 
 (def state-schema

src/main/frontend/db/rtc/op.cljs

@@ -1,7 +1,7 @@
 (ns frontend.db.rtc.op
-  (:require [electron.ipc :as ipc]
-            [malli.core :as m]
-            [cljs.core.async.interop :refer [p->c]]))
+  (:require [malli.core :as m]
+            [frontend.db.rtc.ops-idb-store :as op-store]
+            [promesa.core :as p]))
 
 (def op-schema
   [:or
@@ -17,33 +17,34 @@
 
 (def op-validator (m/validator op-schema))
 
-
-(defn <move-block-op!
+(defn <move-blocks-op!
   [repo block-uuids]
   (let [op ["move" {:block-uuids (mapv str block-uuids)}]]
     (assert (op-validator op) op)
-    (p->c (ipc/ipc :rtc/add-ops repo (pr-str [op])))))
+    (op-store/<add-op! repo op)))
 
 (defn <remove-blocks-op!
   [repo block-uuids]
   (let [op ["remove" {:block-uuids (mapv str block-uuids)}]]
-    (assert (op-validator op) "illegal op")
-    (p->c (ipc/ipc :rtc/add-ops repo (pr-str [op])))))
+    (assert (op-validator op) op)
+    (op-store/<add-op! repo op)))
 
 (defn <update-block-op!
   [repo block-uuid]
   (let [op ["update" {:block-uuid (str block-uuid)}]]
-    (assert (op-validator op) "illegal op")
-    (p->c (ipc/ipc :rtc/add-ops repo (pr-str [op])))))
+    (assert (op-validator op) op)
+    (op-store/<add-op! repo op)))
 
 (defn <get-ops&local-tx
   [repo]
-  (p->c (ipc/ipc :rtc/get-ops&local-tx repo)))
+  (p/let [all-data (op-store/<get-all-ops repo)]
+    (let [all-data-m (into {} all-data)
+          local-tx (get all-data-m "local-tx")
+          ops (->> all-data
+                   (filter (comp number? first))
+                   (sort-by first <))]
+      {:ops ops :local-tx local-tx})))
 
 (defn <clean-ops
-  [repo]
-  (p->c (ipc/ipc :rtc/clean-ops repo)))
-
-(defn <init
-  [repo]
-  (p->c (ipc/ipc :rtc/init repo)))
+  [repo keys]
+  (op-store/<clear-ops! repo keys))

src/main/frontend/db/rtc/ops_idb_store.cljs

@@ -4,35 +4,58 @@
             [promesa.core :as p]
             [cljs-time.core :as t]
             [cljs-time.coerce :as tc]
-            [cljs.core.async.interop :refer [p->c]]
-            [cljs.core.async :as async :refer [poll!]]))
+            [cljs.core.async :as async]
+            [cljs.core.async.interop :refer [p->c]]))
 
 
 (def stores (atom {}))
 
 (defn- ensure-store
-  [graph-uuid]
-  {:pre [(some? graph-uuid)]}
-  (swap! stores assoc graph-uuid (Store. "rtc-ops" graph-uuid))
-  (@stores graph-uuid))
+  [repo]
+  {:pre [(some? repo)]}
+  (swap! stores assoc repo (Store. (str "rtc-ops-" repo) "ops"))
+  (@stores repo))
 
 (defn <update-local-tx!
-  [graph-uuid tx]
-  (idb-keyval/set "local-state" (clj->js {:local-tx tx}) (ensure-store graph-uuid)))
+  [repo tx]
+  (idb-keyval/set "local-tx" (clj->js {:local-tx tx}) (ensure-store repo)))
+
+(defn <update-graph-uuid!
+  [repo graph-uuid]
+  {:pre [(some? graph-uuid)]}
+  (idb-keyval/set "graph-uuid" graph-uuid (ensure-store repo)))
+
+(defn- <add-op*!
+  [repo op]
+  (let [store (ensure-store repo)]
+    (p/loop [key* (tc/to-long (t/now))]
+      (p/let [old-v (idb-keyval/get key* store)]
+        (if old-v
+          (p/recur (inc key*))
+          (idb-keyval/set key* (clj->js op) store))))))
+
+
+(def ^:private add-op-ch (async/chan 100))
+(async/go-loop []
+  (if-let [[repo op] (async/<! add-op-ch)]
+    (do (prn :add-op op)
+        (async/<! (p->c (<add-op*! repo op)))
+        (recur))
+    (recur)))
 
 (defn <add-op!
-  [graph-uuid op]
-  (p/let [store (ensure-store graph-uuid)
-          now (tc/to-long (t/now))
-          old-v (idb-keyval/get now store)
-          key (if old-v (inc now) now)]
-    (idb-keyval/set key (clj->js op) store)))
+  [repo op]
+  (async/go (async/>! add-op-ch [repo op])))
 
+(defn <clear-ops!
+  [repo keys]
+  (let [store (ensure-store repo)]
+    (doseq [k keys]
+      (idb-keyval/del k store))))
 
 (defn <get-all-ops
-  [graph-uuid]
-  (p/let [store (ensure-store graph-uuid)
+  [repo]
+  (p/let [store (ensure-store repo)
           keys (idb-keyval/keys store)]
-    (prn keys)
     (-> (p/all (mapv (fn [k] (p/chain (idb-keyval/get k store) (partial vector k))) keys))
         (p/then (fn [items] (mapv #(js->clj % :keywordize-keys true) items))))))

src/main/frontend/handler.cljs

@@ -88,7 +88,6 @@
     (-> (db-restore/restore-graph! repo)
         (p/then
          (fn []
-           (rtc-core/init-rtc-op-db repo)
            (db-listener/listen-and-persist! repo)
            ;; try to load custom css only for current repo
            (ui-handler/add-style-if-exists!)

src/main/frontend/handler/repo.cljs

@@ -410,7 +410,6 @@
   (p/do!
    (state/set-db-restoring! true)
    (db-restore/restore-graph! repo)
-   (rtc-core/init-rtc-op-db repo)
    (repo-config-handler/restore-repo-config! repo)
    (when (config/global-config-enabled?)
      (global-config-handler/restore-global-config!))

src/main/frontend/modules/outliner/core.cljs

@@ -991,10 +991,7 @@
         repo (:repo *transaction-args*)
         persist-op? (:persist-op? *transaction-args*)]
     (when (and persist-op? repo)
-      (async/go
-        (rtc-op/<move-block-op! repo (keep :block/uuid (:blocks r)))
-        ;; (rtc-op/<update-block-op! repo (:block/uuid))
-        ))
+      (rtc-op/<move-blocks-op! repo (keep :block/uuid (:blocks r))))
     r))
 
 (defn delete-blocks!
@@ -1010,7 +1007,7 @@
   (let [repo (:repo *transaction-args*)
         persist-op? (:persist-op? *transaction-args*)]
     (when (and persist-op? repo)
-      (rtc-op/<move-block-op! repo (keep :block/uuid blocks))))
+      (rtc-op/<move-blocks-op! repo (keep :block/uuid blocks))))
   (op-transact! #'move-blocks blocks target-block {:sibling? sibling?}))
 
 (defn move-blocks-up-down!
@@ -1018,7 +1015,7 @@
   (let [repo (:repo *transaction-args*)
         persist-op? (:persist-op? *transaction-args*)]
     (when (and persist-op? repo)
-      (rtc-op/<move-block-op! repo (keep :block/uuid blocks))))
+      (rtc-op/<move-blocks-op! repo (keep :block/uuid blocks))))
   (op-transact! #'move-blocks-up-down blocks up?))
 
 (defn indent-outdent-blocks!
@@ -1026,5 +1023,5 @@
   (let [repo (:repo *transaction-args*)
         persist-op? (:persist-op? *transaction-args*)]
     (when (and persist-op? repo)
-      (rtc-op/<move-block-op! repo (keep :block/uuid blocks))))
+      (rtc-op/<move-blocks-op! repo (keep :block/uuid blocks))))
   (op-transact! #'indent-outdent-blocks blocks indent?))