refactor: remove defclass DBWorker

src/main/frontend/components/all_pages.cljs

@@ -50,8 +50,8 @@
                                        :with-id? false})]
     (hooks/use-effect!
      (fn []
-       (when-let [^js worker @state/*db-worker]
-         (p/let [result-str (.get-page-refs-count worker (state/get-current-repo))
+       (when-let [worker @state/*db-worker]
+         (p/let [result-str (worker :general/get-page-refs-count (state/get-current-repo))
                  result (ldb/read-transit-str result-str)
                  data (get-all-pages)
                  data (map (fn [row] (assoc row :block.temp/refs-count (get result (:db/id row) 0))) data)]

src/main/frontend/components/content.cljs

@@ -354,10 +354,10 @@
                {:key "(Dev) Show block content history"
                 :on-click
                 (fn []
-                  (let [^object worker @db-browser/*worker
+                  (let [worker @db-browser/*worker
                         token (state/get-auth-id-token)
                         graph-uuid (ldb/get-graph-rtc-uuid (db/get-db))]
-                    (p/let [result (.rtc-get-block-content-versions worker token graph-uuid (str block-id))
+                    (p/let [result (worker :rtc/get-block-content-versions token graph-uuid (str block-id))
                             blocks-versions (ldb/read-transit-str result)]
                       (prn :Dev-show-block-content-history)
                       (doseq [[block-uuid versions] blocks-versions]

src/main/frontend/db/async.cljs

@@ -147,12 +147,12 @@
                name-or-uuid)]
     (if (or (:block.temp/fully-loaded? e) async-requested?)
       e
-      (when-let [^Object sqlite @db-browser/*worker]
+      (when-let [worker @db-browser/*worker]
         (swap! *async-queries assoc [name' opts] true)
         (state/update-state! :db/async-query-loading (fn [s] (conj s name')))
-        (p/let [result (.get-block-and-children sqlite graph id (ldb/write-transit-str
-                                                                 {:children? children?
-                                                                  :nested-children? nested-children?}))
+        (p/let [result (worker :general/get-block-and-children graph id (ldb/write-transit-str
+                                                                         {:children? children?
+                                                                          :nested-children? nested-children?}))
                 {:keys [properties block children] :as result'} (ldb/read-transit-str result)
                 conn (db/get-db graph false)
                 block-and-children (concat properties [block] children)
@@ -168,10 +168,10 @@
 (defn <get-block-parents
   [graph id depth]
   (assert (integer? id))
-  (when-let [^Object worker @db-browser/*worker]
+  (when-let [worker @db-browser/*worker]
     (when-let [block-id (:block/uuid (db/entity graph id))]
       (state/update-state! :db/async-query-loading (fn [s] (conj s (str block-id "-parents"))))
-      (p/let [result-str (.get-block-parents worker graph id depth)
+      (p/let [result-str (worker :general/get-block-parents graph id depth)
               result (ldb/read-transit-str result-str)
               conn (db/get-db graph false)
               _ (d/transact! conn result)]
@@ -182,20 +182,20 @@
   [page-name]
   (when-let [page (some-> page-name (db-model/get-page))]
     (when-let [^Object worker @db-browser/*worker]
-      (p/let [result (.get-block-and-children worker
-                                              (state/get-current-repo)
-                                              (str (:block/uuid page))
-                                              (ldb/write-transit-str
-                                               {:children? true
-                                                :nested-children? false}))]
+      (p/let [result (worker :general/get-block-and-children
+                             (state/get-current-repo)
+                             (str (:block/uuid page))
+                             (ldb/write-transit-str
+                              {:children? true
+                               :nested-children? false}))]
         (some-> result (ldb/read-transit-str) (:children))))))
 
 (defn <get-block-refs
   [graph eid]
   (assert (integer? eid))
-  (when-let [^Object worker @db-browser/*worker]
+  (when-let [worker @db-browser/*worker]
     (state/update-state! :db/async-query-loading (fn [s] (conj s (str eid "-refs"))))
-    (p/let [result-str (.get-block-refs worker graph eid)
+    (p/let [result-str (worker :general/get-block-refs graph eid)
             result (ldb/read-transit-str result-str)
             conn (db/get-db graph false)
             _ (d/transact! conn result)]
@@ -205,8 +205,8 @@
 (defn <get-block-refs-count
   [graph eid]
   (assert (integer? eid))
-  (when-let [^Object worker @db-browser/*worker]
-    (.get-block-refs-count worker graph eid)))
+  (when-let [worker @db-browser/*worker]
+    (worker :general/get-block-refs-count graph eid)))
 
 (defn <get-all-referenced-blocks-uuid
   "Get all uuids of blocks with any back link exists."
@@ -381,13 +381,3 @@
                            (recur (cons item others) time'))))
                      (quot time 1000)))]
         [status-history time]))))
-
-(comment
-  (defn <fetch-all-pages
-    [graph]
-    (when-let [^Object worker @db-browser/*worker]
-      (let [db (db/get-db graph)
-            exclude-ids (->> (d/datoms db :avet :block/name)
-                             (map :db/id)
-                             (ldb/write-transit-str))]
-        (.fetch-all-pages worker graph exclude-ids)))))

src/main/frontend/db/async/util.cljs

@@ -11,13 +11,13 @@
           :or {transact-db? true}
           :as opts} & inputs]
   (assert (not-any? fn? inputs) "Async query inputs can't include fns because fn can't be serialized")
-  (when-let [^Object sqlite @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (let [*async-queries (:db/async-queries @state/state)
           async-requested? (get @*async-queries [inputs opts])]
       (if async-requested?
         (let [db (db-conn/get-db graph)]
           (apply d/q (first inputs) db (rest inputs)))
-        (p/let [result (.q sqlite graph (ldb/write-transit-str inputs))]
+        (p/let [result (worker :general/q graph (ldb/write-transit-str inputs))]
           (swap! *async-queries assoc [inputs opts] true)
           (when result
             (let [result' (ldb/read-transit-str result)]
@@ -42,19 +42,10 @@
   ([graph id]
    (<pull graph '[*] id))
   ([graph selector id]
-   (when-let [^Object sqlite @state/*db-worker]
-     (p/let [result (.pull sqlite graph (ldb/write-transit-str selector) (ldb/write-transit-str id))]
+   (when-let [worker @state/*db-worker]
+     (p/let [result (worker :general/pull graph (ldb/write-transit-str selector) (ldb/write-transit-str id))]
        (when result
          (let [result' (ldb/read-transit-str result)]
            (when-let [conn (db-conn/get-db graph false)]
              (d/transact! conn [result']))
            result'))))))
-
-(comment
-  (defn <pull-many
-    [graph selector ids]
-    (assert (seq ids))
-    (when-let [^Object sqlite @state/*db-worker]
-      (p/let [result (.pull-many sqlite graph (ldb/write-transit-str selector) (ldb/write-transit-str ids))]
-        (when result
-          (ldb/read-transit-str result))))))

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

@@ -20,8 +20,8 @@
 
 (defn- stop
   []
-  (let [^object worker @db-browser/*worker]
-    (.rtc-stop worker))
+  (let [worker @db-browser/*worker]
+    (worker :rtc/stop))
   (reset! debug-state nil))
 
 (rum/defcs ^:large-vars/cleanup-todo rtc-debug-ui < rum/reactive
@@ -60,8 +60,8 @@
       (shui/button
        {:size :sm
         :on-click (fn [_]
-                    (let [^object worker @db-browser/*worker]
-                      (p/let [result (.rtc-get-debug-state worker)
+                    (let [worker @db-browser/*worker]
+                      (p/let [result (worker :rtc/get-debug-state)
                               new-state (ldb/read-transit-str result)]
                         (swap! debug-state (fn [old] (merge old new-state))))))}
        (shui/tabler-icon "refresh") "state")
@@ -71,8 +71,8 @@
         :on-click
         (fn [_]
           (let [token (state/get-auth-id-token)
-                ^object worker @db-browser/*worker]
-            (p/let [result (.rtc-get-graphs worker token)
+                worker @db-browser/*worker]
+            (p/let [result (worker :rtc/get-graphs token)
                     graph-list (ldb/read-transit-str result)]
               (swap! debug-state assoc
                      :remote-graphs
@@ -121,8 +121,8 @@
          :class "text-green-rx-09 border-green-rx-10 hover:text-green-rx-10"
          :on-click (fn []
                      (let [token (state/get-auth-id-token)
-                           ^object worker @db-browser/*worker]
-                       (.rtc-start worker (state/get-current-repo) token)))}
+                           worker @db-browser/*worker]
+                       (worker :rtc/start (state/get-current-repo) token)))}
         (shui/tabler-icon "player-play") "start")
 
        [:div.my-2.flex
@@ -132,16 +132,16 @@
                                    ")")
                               {:on-click
                                (fn []
-                                 (let [^object worker @db-browser/*worker]
-                                   (.rtc-toggle-auto-push worker)))})]
+                                 (let [worker @db-browser/*worker]
+                                   (worker :rtc/toggle-auto-push)))})]
         [:div.mr-2 (ui/button (str "Toggle remote profile("
                                    (if (:remote-profile? debug-state*)
                                      "ON" "OFF")
                                    ")")
                               {:on-click
                                (fn []
-                                 (let [^object worker @db-browser/*worker]
-                                   (.rtc-toggle-remote-profile worker)))})]
+                                 (let [worker @db-browser/*worker]
+                                   (worker :rtc/toggle-remote-profile)))})]
         [:div (shui/button
                {:variant :outline
                 :class "text-red-rx-09 border-red-rx-08 hover:text-red-rx-10"
@@ -159,10 +159,11 @@
                                       user-uuid (some-> (:grant-access-to-user debug-state*) parse-uuid)
                                       user-email (when-not user-uuid (:grant-access-to-user debug-state*))]
                                   (when-let [graph-uuid (:graph-uuid debug-state*)]
-                                    (let [^object worker @db-browser/*worker]
-                                      (.rtc-grant-graph-access worker token graph-uuid
-                                                               (some-> user-uuid vector ldb/write-transit-str)
-                                                               (some-> user-email vector ldb/write-transit-str))))))})
+                                    (let [worker @db-browser/*worker]
+                                      (worker :rtc/grant-graph-access
+                                              token graph-uuid
+                                              (some-> user-uuid vector ldb/write-transit-str)
+                                              (some-> user-email vector ldb/write-transit-str))))))})
 
         [:b "➡️"]
         [:input.form-input.my-2.py-1
@@ -182,14 +183,14 @@
                               (when-let [graph-name (:download-graph-to-repo debug-state*)]
                                 (when-let [{:keys [graph-uuid graph-schema-version]}
                                            (:graph-uuid-to-download debug-state*)]
-                                  (let [^object worker @db-browser/*worker]
+                                  (let [worker @db-browser/*worker]
                                     (prn :download-graph graph-uuid graph-schema-version :to graph-name)
                                     (p/let [token (state/get-auth-id-token)
-                                            download-info-uuid (.rtc-request-download-graph
-                                                                worker token graph-uuid graph-schema-version)
+                                            download-info-uuid (worker :rtc/request-download-graph
+                                                                       token graph-uuid graph-schema-version)
                                             download-info-uuid (ldb/read-transit-str download-info-uuid)
-                                            result (.rtc-wait-download-graph-info-ready
-                                                    worker token download-info-uuid graph-uuid graph-schema-version 60000)
+                                            result (worker :rtc/wait-download-graph-info-ready
+                                                           token download-info-uuid graph-uuid graph-schema-version 60000)
                                             {:keys [_download-info-uuid
                                                     download-info-s3-url
                                                     _download-info-tx-instant
@@ -198,7 +199,8 @@
                                              :as result} (ldb/read-transit-str result)]
                                       (when (not= result :timeout)
                                         (assert (some? download-info-s3-url) result)
-                                        (.rtc-download-graph-from-s3 worker graph-uuid graph-name download-info-s3-url)))))))})
+                                        (worker :rtc/download-graph-from-s3
+                                                graph-uuid graph-name download-info-s3-url)))))))})
 
       [:b "➡"]
       [:div.flex.flex-row.items-center.gap-2
@@ -233,8 +235,8 @@
                               (let [repo (state/get-current-repo)
                                     token (state/get-auth-id-token)
                                     remote-graph-name (:upload-as-graph-name debug-state*)
-                                    ^js worker @db-browser/*worker]
-                                (.rtc-async-upload-graph worker repo token remote-graph-name)))})
+                                    worker @db-browser/*worker]
+                                (worker :rtc/async-upload-graph repo token remote-graph-name)))})
       [:b "➡️"]
       [:input.form-input.my-2.py-1.w-32
        {:on-change (fn [e] (swap! debug-state assoc :upload-as-graph-name (util/evalue e)))
@@ -249,9 +251,9 @@
                   :on-click (fn []
                               (when-let [{:keys [graph-uuid graph-schema-version]} (:graph-uuid-to-delete debug-state*)]
                                 (let [token (state/get-auth-id-token)
-                                      ^object worker @db-browser/*worker]
+                                      worker @db-browser/*worker]
                                   (prn ::delete-graph graph-uuid graph-schema-version)
-                                  (.rtc-delete-graph worker token graph-uuid graph-schema-version))))})
+                                  (worker :rtc/delete-graph token graph-uuid graph-schema-version))))})
 
       (shui/select
        {:on-value-change (fn [[graph-uuid graph-schema-version]]
@@ -278,10 +280,10 @@
          (shui/button
           {:size :sm
            :on-click (fn [_]
-                       (let [^object worker @db-browser/*worker]
-                         (p/let [result1 (.rtc-get-graph-keys worker (state/get-current-repo))
+                       (let [worker @db-browser/*worker]
+                         (p/let [result1 (worker :rtc/get-graph-keys (state/get-current-repo))
                                  graph-keys (ldb/read-transit-str result1)
-                                 result2 (some->> (state/get-auth-id-token) (.device-list-devices worker))
+                                 result2 (some->> (state/get-auth-id-token) (worker :device/list-devices))
                                  devices (ldb/read-transit-str result2)]
                            (swap! (get state ::keys-state) #(merge % graph-keys {:devices devices})))))}
           (shui/tabler-icon "refresh") "keys-state")]
@@ -294,10 +296,10 @@
         (shui/button
          {:size :sm
           :on-click (fn [_]
-                      (let [^object worker @db-browser/*worker]
+                      (let [worker @db-browser/*worker]
                         (when-let [device-uuid (not-empty (:remove-device-device-uuid keys-state))]
                           (when-let [token (state/get-auth-id-token)]
-                            (.device-remove-device worker token device-uuid)))))}
+                            (worker :device/remove-device token device-uuid)))))}
          "Remove device:")
         [:input.form-input.my-2.py-1.w-32
          {:on-change (fn [e] (swap! *keys-state assoc :remove-device-device-uuid (util/evalue e)))
@@ -308,11 +310,11 @@
         (shui/button
          {:size :sm
           :on-click (fn [_]
-                      (let [^object worker @db-browser/*worker]
+                      (let [worker @db-browser/*worker]
                         (when-let [device-uuid (not-empty (:remove-public-key-device-uuid keys-state))]
                           (when-let [key-name (not-empty (:remove-public-key-key-name keys-state))]
                             (when-let [token (state/get-auth-id-token)]
-                              (.device-remove-device-public-key worker token device-uuid key-name))))))}
+                              (worker :device/remove-device-public-key token device-uuid key-name))))))}
          "Remove public-key:")
         [:input.form-input.my-2.py-1.w-32
          {:on-change (fn [e] (swap! *keys-state assoc :remove-public-key-device-uuid (util/evalue e)))
@@ -332,8 +334,8 @@
                       (let [^object worker @db-browser/*worker]
                         (when-let [token (state/get-auth-id-token)]
                           (when-let [device-uuid (not-empty (:sync-private-key-device-uuid keys-state))]
-                            (.rtc-sync-current-graph-encrypted-aes-key
-                             worker token (ldb/write-transit-str [(parse-uuid device-uuid)]))))))}
+                            (worker :rtc/sync-current-graph-encrypted-aes-key
+                                    token (ldb/write-transit-str [(parse-uuid device-uuid)]))))))}
          "Sync CurrentGraph EncryptedAesKey")
         [:input.form-input.my-2.py-1.w-32
          {:on-change (fn [e] (swap! *keys-state assoc :sync-private-key-device-uuid (util/evalue e)))

src/main/frontend/handler/common/developer.cljs

@@ -90,8 +90,8 @@
         (notification/show! "No page found" :warning)))))
 
 (defn ^:export validate-db []
-  (when-let [^Object worker @state/*db-worker]
-    (.validate-db worker (state/get-current-repo))))
+  (when-let [worker @state/*db-worker]
+    (worker :general/validate-db (state/get-current-repo))))
 
 (defn import-chosen-graph
   [repo]

src/main/frontend/handler/db_based/export.cljs

@@ -14,10 +14,10 @@
 (defn ^:export export-block-data []
   ;; Use editor state to locate most recent block
   (if-let [block-uuid (:block-id (first (state/get-editor-args)))]
-    (when-let [^Object worker @state/*db-worker]
-      (p/let [result* (.export-edn worker
-                                   (state/get-current-repo)
-                                   (ldb/write-transit-str {:export-type :block :block-id [:block/uuid block-uuid]}))
+    (when-let [worker @state/*db-worker]
+      (p/let [result* (worker :general/export-edn
+                              (state/get-current-repo)
+                              (ldb/write-transit-str {:export-type :block :block-id [:block/uuid block-uuid]}))
               result (ldb/read-transit-str result*)
               pull-data (with-out-str (pprint/pprint result))]
         (.writeText js/navigator.clipboard pull-data)
@@ -27,10 +27,10 @@
 
 (defn export-view-nodes-data [nodes]
   (let [block-uuids (mapv #(vector :block/uuid (:block/uuid %)) nodes)]
-    (when-let [^Object worker @state/*db-worker]
-      (p/let [result* (.export-edn worker
-                                   (state/get-current-repo)
-                                   (ldb/write-transit-str {:export-type :view-nodes :node-ids block-uuids}))
+    (when-let [worker @state/*db-worker]
+      (p/let [result* (worker :general/export-edn
+                              (state/get-current-repo)
+                              (ldb/write-transit-str {:export-type :view-nodes :node-ids block-uuids}))
               result (ldb/read-transit-str result*)
               pull-data (with-out-str (pprint/pprint result))]
         (.writeText js/navigator.clipboard pull-data)
@@ -39,8 +39,9 @@
 
 (defn ^:export export-page-data []
   (if-let [page-id (page-util/get-current-page-id)]
-    (when-let [^Object worker @state/*db-worker]
-      (p/let [result* (.export-edn worker (state/get-current-repo) (ldb/write-transit-str {:export-type :page :page-id page-id}))
+    (when-let [worker @state/*db-worker]
+      (p/let [result* (worker :general/export-edn
+                              (state/get-current-repo) (ldb/write-transit-str {:export-type :page :page-id page-id}))
               result (ldb/read-transit-str result*)
               pull-data (with-out-str (pprint/pprint result))]
         (.writeText js/navigator.clipboard pull-data)
@@ -49,8 +50,9 @@
     (notification/show! "No page found" :warning)))
 
 (defn ^:export export-graph-ontology-data []
-  (when-let [^Object worker @state/*db-worker]
-    (p/let [result* (.export-edn worker (state/get-current-repo) (ldb/write-transit-str {:export-type :graph-ontology}))
+  (when-let [worker @state/*db-worker]
+    (p/let [result* (worker :general/export-edn
+                            (state/get-current-repo) (ldb/write-transit-str {:export-type :graph-ontology}))
             result (ldb/read-transit-str result*)
             pull-data (with-out-str (pprint/pprint result))]
       (.writeText js/navigator.clipboard pull-data)
@@ -60,11 +62,11 @@
       (notification/show! "Copied graphs's ontology data!" :success))))
 
 (defn- export-graph-edn-data []
-  (when-let [^Object worker @state/*db-worker]
-    (p/let [result* (.export-edn worker
-                                 (state/get-current-repo)
-                                 (ldb/write-transit-str {:export-type :graph
-                                                         :graph-options {:include-timestamps? true}}))
+  (when-let [worker @state/*db-worker]
+    (p/let [result* (worker :general/export-edn
+                            (state/get-current-repo)
+                            (ldb/write-transit-str {:export-type :graph
+                                                    :graph-options {:include-timestamps? true}}))
             result (ldb/read-transit-str result*)
             pull-data (with-out-str (pprint/pprint result))]
       pull-data)))
@@ -87,4 +89,4 @@
         (when-let [anchor (gdom/getElement "download-as-db-edn")]
           (.setAttribute anchor "href" data-str)
           (.setAttribute anchor "download" filename)
-          (.click anchor))))))
+          (.click anchor))))))

src/main/frontend/handler/db_based/rtc.cljs

@@ -16,32 +16,32 @@
 
 (defn <rtc-create-graph!
   [repo]
-  (when-let [^js worker @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (p/do!
      (js/Promise. user-handler/task--ensure-id&access-token)
      (let [token (state/get-auth-id-token)
            repo-name (sqlite-common-db/sanitize-db-name repo)]
-       (.rtc-async-upload-graph worker repo token repo-name)))))
+       (worker :rtc/async-upload-graph repo token repo-name)))))
 
 (defn <rtc-delete-graph!
   [graph-uuid schema-version]
-  (when-let [^js worker @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (p/do!
      (js/Promise. user-handler/task--ensure-id&access-token)
      (let [token (state/get-auth-id-token)]
-       (.rtc-delete-graph worker token graph-uuid schema-version)))))
+       (worker :rtc/delete-graph token graph-uuid schema-version)))))
 
 (defn <rtc-download-graph!
   [graph-name graph-uuid graph-schema-version timeout-ms]
   (assert (some? graph-schema-version))
-  (when-let [^js worker @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (state/set-state! :rtc/downloading-graph-uuid graph-uuid)
     (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)
             token (state/get-auth-id-token)
-            download-info-uuid* (.rtc-request-download-graph worker token graph-uuid graph-schema-version)
+            download-info-uuid* (worker :rtc/request-download-graph token graph-uuid graph-schema-version)
             download-info-uuid (ldb/read-transit-str download-info-uuid*)
-            result (.rtc-wait-download-graph-info-ready
-                    worker token download-info-uuid graph-uuid graph-schema-version timeout-ms)
+            result (worker :rtc/wait-download-graph-info-ready
+                           token download-info-uuid graph-uuid graph-schema-version timeout-ms)
             {:keys [_download-info-uuid
                     download-info-s3-url
                     _download-info-tx-instant
@@ -51,21 +51,21 @@
       (->
        (when (not= result :timeout)
          (assert (some? download-info-s3-url) result)
-         (.rtc-download-graph-from-s3 worker graph-uuid graph-name download-info-s3-url))
+         (worker :rtc/download-graph-from-s3 graph-uuid graph-name download-info-s3-url))
        (p/finally
          #(state/set-state! :rtc/downloading-graph-uuid nil))))))
 
 (defn <rtc-stop!
   []
-  (when-let [^js worker @state/*db-worker]
-    (.rtc-stop worker)))
+  (when-let [worker @state/*db-worker]
+    (worker :rtc/stop)))
 
 (defn <rtc-branch-graph!
   [repo]
-  (when-let [^js worker @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)
             token (state/get-auth-id-token)
-            result (.rtc-async-branch-graph worker repo token)
+            result (worker :rtc/async-branch-graph repo token)
             start-ex (ldb/read-transit-str result)]
       (when-let [ex-data* (:ex-data start-ex)]
         (throw (ex-info (:ex-message start-ex) ex-data*))))))
@@ -99,13 +99,13 @@
 
 (defn <rtc-start!
   [repo & {:keys [stop-before-start?] :or {stop-before-start? true}}]
-  (when-let [^js worker @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (when-let [graph-uuid (ldb/get-graph-rtc-uuid (db/get-db repo))]
       (p/do!
        (js/Promise. user-handler/task--ensure-id&access-token)
        (when stop-before-start? (<rtc-stop!))
        (let [token (state/get-auth-id-token)]
-         (p/let [result (.rtc-start worker repo token)
+         (p/let [result (worker :rtc/start repo token)
                  start-ex (ldb/read-transit-str result)
                  ex-data* (:ex-data start-ex)
                  _ (case (:type ex-data*)
@@ -138,10 +138,10 @@
 
 (defn <get-remote-graphs
   []
-  (when-let [^js worker @state/*db-worker]
+  (when-let [worker @state/*db-worker]
     (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)
             token (state/get-auth-id-token)
-            result (.rtc-get-graphs worker token)
+            result (worker :rtc/get-graphs token)
             graphs (ldb/read-transit-str result)
             result (->> graphs
                         (remove (fn [graph] (= (:graph-status graph) "deleting")))
@@ -159,10 +159,10 @@
 (defn <rtc-get-users-info
   []
   (when-let [graph-uuid (ldb/get-graph-rtc-uuid (db/get-db))]
-    (when-let [^js worker @state/*db-worker]
+    (when-let [worker @state/*db-worker]
       (p/let [token (state/get-auth-id-token)
               repo (state/get-current-repo)
-              result (.rtc-get-users-info worker token (str graph-uuid))
+              result (worker :rtc/get-users-info token (str graph-uuid))
               result (ldb/read-transit-str result)]
         (state/set-state! :rtc/users-info {repo result})))))
 
@@ -172,9 +172,10 @@
     (let [token (state/get-auth-id-token)]
       (->
        (p/do!
-        (.rtc-grant-graph-access worker token (str graph-uuid)
-                                 (ldb/write-transit-str [])
-                                 (ldb/write-transit-str [email]))
+        (worker :rtc/grant-graph-access
+                token (str graph-uuid)
+                (ldb/write-transit-str [])
+                (ldb/write-transit-str [email]))
         (notification/show! "Invitation sent!" :success))
        (p/catch (fn [e]
                   (notification/show! "Something wrong, please try again." :error)

src/main/frontend/handler/editor/lifecycle.cljs

@@ -34,11 +34,11 @@
 
     ;; skip recording editor info when undo or redo is still running
     (when-not (contains? #{:undo :redo} @(:editor/op @state/state))
-      (let [^js worker @state/*db-worker
+      (let [worker @state/*db-worker
             page-id (:block/uuid (:block/page (db/entity (:db/id (state/get-edit-block)))))
             repo (state/get-current-repo)]
         (when page-id
-          (.record-editor-info worker repo (str page-id) (ldb/write-transit-str (state/get-editor-info))))))
+          (worker :undo-redo/record-editor-info repo (str page-id) (ldb/write-transit-str (state/get-editor-info))))))
 
     (state/set-state! :editor/op nil))
   state)

src/main/frontend/handler/events.cljs

@@ -205,8 +205,8 @@
   (st/refresh!)
   (reset! r/*key->atom {})
 
-  (let [^js sqlite @db-browser/*worker]
-    (p/let [writes-finished? (when sqlite (.file-writes-finished? sqlite (state/get-current-repo)))
+  (let [worker @db-browser/*worker]
+    (p/let [writes-finished? (when worker (worker :general/file-writes-finished? (state/get-current-repo)))
             request-finished? (db-transact/request-finished?)]
       (if (not writes-finished?) ; TODO: test (:sync-graph/init? @state/state)
         (do
@@ -365,8 +365,9 @@
                  :journals-directory (config/get-journals-directory)
                  :whiteboards-directory (config/get-whiteboards-directory)
                  :pages-directory (config/get-pages-directory)}
-        worker ^Object @state/*db-worker]
-    (when worker (.set-context worker (ldb/write-transit-str context)))))
+        worker @state/*db-worker]
+    (when worker
+      (worker :general/set-context (ldb/write-transit-str context)))))
 
 ;; Hook on a graph is ready to be shown to the user.
 ;; It's different from :graph/restored, as :graph/restored is for window reloaded

src/main/frontend/handler/export/common.cljs

@@ -190,19 +190,19 @@
 
 (defn <get-all-pages
   [repo]
-  (when-let [^object worker @db-browser/*worker]
-    (p/let [result (.get-all-pages worker repo)]
+  (when-let [worker @db-browser/*worker]
+    (p/let [result (worker :export/get-all-pages repo)]
       (ldb/read-transit-str result))))
 
 (defn <get-debug-datoms
   [repo]
-  (when-let [^object worker @db-browser/*worker]
-    (.get-debug-datoms worker repo)))
+  (when-let [worker @db-browser/*worker]
+    (worker :export/get-debug-datoms repo)))
 
 (defn <get-all-page->content
   [repo]
-  (when-let [^object worker @db-browser/*worker]
-    (p/let [result (.get-all-page->content worker repo)]
+  (when-let [worker @db-browser/*worker]
+    (p/let [result (worker :export/get-all-page->content repo)]
       (ldb/read-transit-str result))))
 
 (defn <get-file-contents

src/main/frontend/handler/history.cljs

@@ -7,9 +7,9 @@
             [frontend.state :as state]
             [frontend.util :as util]
             [frontend.util.page :as page-util]
+            [goog.functions :refer [debounce]]
             [logseq.db :as ldb]
-            [promesa.core :as p]
-            [goog.functions :refer [debounce]]))
+            [promesa.core :as p]))
 
 (defn- restore-cursor!
   [{:keys [editor-cursors block-content undo?]}]
@@ -58,8 +58,8 @@
               (state/set-state! [:editor/last-replace-ref-content-tx repo] nil)
               (editor/save-current-block!)
               (state/clear-editor-action!)
-              (let [^js worker @state/*db-worker]
-                (reset! *last-request (.undo worker repo current-page-uuid-str))
+              (let [worker @state/*db-worker]
+                (reset! *last-request (worker :undo-redo/undo repo current-page-uuid-str))
                 (p/let [result @*last-request]
                   (restore-cursor-and-state! result)))))))))))
 (defonce undo! (debounce undo-aux! 20))
@@ -79,8 +79,8 @@
            (when (db-transact/request-finished?)
              (util/stop e)
              (state/clear-editor-action!)
-             (let [^js worker @state/*db-worker]
-               (reset! *last-request (.redo worker repo current-page-uuid-str))
+             (let [worker @state/*db-worker]
+               (reset! *last-request (worker :undo-redo/redo repo current-page-uuid-str))
                (p/let [result @*last-request]
                  (restore-cursor-and-state! result))))))))))
 (defonce redo! (debounce redo-aux! 20))

src/main/frontend/handler/worker.cljs

@@ -10,18 +10,18 @@
 
 (defmulti handle identity)
 
-(defmethod handle :write-files [_ ^js worker data]
+(defmethod handle :write-files [_ worker data]
   (let [{:keys [request-id page-id repo files]} data]
     (->
      (p/let [_ (file-handler/alter-files repo files {})]
-       (.page-file-saved worker request-id page-id))
+       (worker :general/page-file-saved request-id page-id))
      (p/catch (fn [error]
                 (notification/show!
                  [:div
                   [:p "Write file failed, please copy the changes to other editors in case of losing data."]
                   "Error: " (str (.-stack error))]
                  :error)
-                (.page-file-saved worker request-id page-id))))))
+                (worker :general/page-file-saved request-id page-id))))))
 
 (defmethod handle :notification [_ _worker data]
   (apply notification/show! data))

src/main/frontend/modules/outliner/ui.cljc

@@ -31,12 +31,13 @@
                                                 ~opts))
                (when (and worker# (seq r#))
                  (let [request-id# (frontend.state/get-worker-next-request-id)
-                       request# #(.apply-outliner-ops ^Object worker# (frontend.state/get-current-repo)
-                                                      (logseq.db/write-transit-str r#)
-                                                      (logseq.db/write-transit-str
-                                                       (assoc ~opts
-                                                              :request-id request-id#
-                                                              :editor-info editor-info#)))
+                       request# #(worker# :general/apply-outliner-ops
+                                          (frontend.state/get-current-repo)
+                                          (logseq.db/write-transit-str r#)
+                                          (logseq.db/write-transit-str
+                                           (assoc ~opts
+                                                  :request-id request-id#
+                                                  :editor-info editor-info#)))
                        response# (frontend.state/add-worker-request! request-id# request#)]
 
                    response#)))))))))

src/main/frontend/persist_db/browser.cljs

@@ -26,7 +26,7 @@
       (js/console.warn "OPFS storage may be cleared by the browser under storage pressure."))))
 
 (defn- sync-app-state!
-  [^js worker]
+  [worker]
   (add-watch state/state
              :sync-worker-state
              (fn [_ _ prev current]
@@ -37,7 +37,7 @@
                                  (not= (:config prev) (:config current))
                                  (assoc :config (:config current)))]
                  (when (seq new-state)
-                   (.sync-app-state worker (ldb/write-transit-str new-state)))))))
+                   (worker :general/sync-app-state (ldb/write-transit-str new-state)))))))
 
 (defn get-route-data
   [route-match]
@@ -58,12 +58,13 @@
                        old-state (f prev)
                        new-state (f current)]
                    (when (not= new-state old-state)
-                     (.sync-ui-state worker (state/get-current-repo)
-                                     (ldb/write-transit-str {:old-state old-state
-                                                             :new-state new-state}))))))))
+                     (worker :general/sync-ui-state
+                             (state/get-current-repo)
+                             (ldb/write-transit-str {:old-state old-state
+                                                     :new-state new-state}))))))))
 
 (defn transact!
-  [^js worker repo tx-data tx-meta]
+  [worker repo tx-data tx-meta]
   (let [tx-meta' (ldb/write-transit-str tx-meta)
         tx-data' (ldb/write-transit-str tx-data)
         ;; TODO: a better way to share those information with worker, maybe using the state watcher to notify the worker?
@@ -80,8 +81,7 @@
                  :whiteboards-directory (config/get-whiteboards-directory)
                  :pages-directory (config/get-pages-directory)}]
     (if worker
-      (.transact worker repo tx-data' tx-meta'
-                 (ldb/write-transit-str context))
+      (worker :general/transact repo tx-data' tx-meta' (ldb/write-transit-str context))
       (notification/show! "Latest change was not saved! Please restart the application." :error))))
 
 (defn- with-write-transit-str
@@ -120,17 +120,21 @@
                        "js/db-worker.js"
                        "static/js/db-worker.js")
           worker (js/Worker. (str worker-url "?electron=" (util/electron?) "&publishing=" config/publishing?))
-          wrapped-worker (Comlink/wrap worker)
+          wrapped-worker* (Comlink/wrap worker)
+          wrapped-worker (fn [qkw & args]
+                           (.remoteInvoke ^js wrapped-worker*
+                                          (str (namespace qkw) "/" (name qkw))
+                                          (ldb/write-transit-str args)))
           t1 (util/time-ms)]
       (Comlink/expose (Main.) worker)
-      (worker-handler/handle-message! worker wrapped-worker)
+      (worker-handler/handle-message! worker wrapped-worker*)
       (reset! *worker wrapped-worker)
-      (-> (p/let [_ (.init wrapped-worker config/RTC-WS-URL)
+      (-> (p/let [_ (wrapped-worker :general/init config/RTC-WS-URL)
                   _ (js/console.debug (str "debug: init worker spent: " (- (util/time-ms) t1) "ms"))
-                  _ (.sync-app-state wrapped-worker
-                                     (ldb/write-transit-str
-                                      {:git/current-repo (state/get-current-repo)
-                                       :config (:config @state/state)}))
+                  _ (wrapped-worker :general/sync-app-state
+                                    (ldb/write-transit-str
+                                     {:git/current-repo (state/get-current-repo)
+                                      :config (:config @state/state)}))
                   _ (sync-app-state! wrapped-worker)
                   _ (sync-ui-state! wrapped-worker)
                   _ (ask-persist-permission!)
@@ -171,36 +175,36 @@
 (defrecord InBrowser []
   protocol/PersistentDB
   (<new [_this repo opts]
-    (when-let [^js sqlite @*worker]
-      (.createOrOpenDB sqlite repo (ldb/write-transit-str opts))))
+    (when-let [worker @*worker]
+      (worker :general/create-or-open-db repo (ldb/write-transit-str opts))))
 
   (<list-db [_this]
-    (when-let [^js sqlite @*worker]
-      (-> (.listDB sqlite)
+    (when-let [worker @*worker]
+      (-> (worker :general/list-db)
           (p/then ldb/read-transit-str)
           (p/catch sqlite-error-handler))))
 
   (<unsafe-delete [_this repo]
-    (when-let [^js sqlite @*worker]
-      (.unsafeUnlinkDB sqlite repo)))
+    (when-let [worker @*worker]
+      (worker :general/unsafe-unlink-db repo)))
 
   (<release-access-handles [_this repo]
-    (when-let [^js sqlite @*worker]
-      (.releaseAccessHandles sqlite repo)))
+    (when-let [worker @*worker]
+      (worker :general/release-access-handles repo)))
 
   (<fetch-initial-data [_this repo opts]
-    (when-let [^js sqlite @*worker]
-      (-> (p/let [db-exists? (.dbExists sqlite repo)
+    (when-let [^js worker @*worker]
+      (-> (p/let [db-exists? (worker :general/db-exists repo)
                   disk-db-data (when-not db-exists? (ipc/ipc :db-get repo))
                   _ (when disk-db-data
-                      (.importDb sqlite repo disk-db-data))
-                  _ (.createOrOpenDB sqlite repo (ldb/write-transit-str opts))]
-            (.getInitialData sqlite repo))
+                      (worker :general/import-db repo disk-db-data))
+                  _ (worker :general/create-or-open-db repo (ldb/write-transit-str opts))]
+            (worker :general/get-initial-data repo))
           (p/catch sqlite-error-handler))))
 
   (<export-db [_this repo opts]
-    (when-let [^js sqlite @*worker]
-      (-> (p/let [data (.exportDB sqlite repo)]
+    (when-let [worker @*worker]
+      (-> (p/let [data (worker :general/export-db repo)]
             (when data
               (if (:return-data? opts)
                 data
@@ -211,8 +215,8 @@
                      (notification/show! [:div (str "SQLiteDB save error: " error)] :error) {})))))
 
   (<import-db [_this repo data]
-    (when-let [^js sqlite @*worker]
-      (-> (.importDb sqlite repo data)
+    (when-let [worker @*worker]
+      (-> (worker :general/import-db repo data)
           (p/catch (fn [error]
                      (prn :debug :import-db-error repo)
                      (js/console.error error)
@@ -221,6 +225,6 @@
 (comment
   (defn clean-all-dbs!
     []
-    (when-let [sqlite @*sqlite]
-      (.dangerousRemoveAllDbs sqlite)
+    (when-let [worker @*worker]
+      (worker :general/dangerousRemoveAllDbs)
       (state/set-current-repo! nil))))

src/main/frontend/publishing.cljs

@@ -56,8 +56,8 @@
       (state/set-current-repo! repo)
       (p/let [_ (repo-handler/restore-and-setup-repo! repo)
               _ (let [db-transit-str (unescape-html data)]
-                  (when-let [^js worker @state/*db-worker]
-                    (.resetDB worker repo db-transit-str)))
+                  (when-let [worker @state/*db-worker]
+                    (worker :general/reset-db repo db-transit-str)))
               _ (repo-handler/restore-and-setup-repo! repo)]
         (state/set-db-restoring! false)
         (ui-handler/re-render-root!)))))

src/main/frontend/search.cljs

@@ -127,7 +127,7 @@
                       (remove (fn [b] (= (:block/uuid b) (:block/uuid entity))))
                       (map (fn [b] [:block/uuid (:block/uuid b)])))
             result (when (seq eids)
-                     (.get-page-unlinked-refs ^Object @state/*db-worker repo (:db/id entity) (ldb/write-transit-str eids)))
+                     (@state/*db-worker :general/get-page-unlinked-refs repo (:db/id entity) (ldb/write-transit-str eids)))
             result' (when result (ldb/read-transit-str result))]
       (when result' (d/transact! (db/get-db repo false) result'))
       (some->> result'

src/main/frontend/search/browser.cljs

@@ -1,33 +1,33 @@
 (ns frontend.search.browser
   "Browser implementation of search protocol"
   (:require [cljs-bean.core :as bean]
-            [frontend.search.protocol :as protocol]
-            [promesa.core :as p]
-            [frontend.persist-db.browser :as browser]
-            [frontend.state :as state]
             [frontend.config :as config]
             [frontend.handler.file-based.property.util :as property-util]
-            [logseq.db :as ldb]))
+            [frontend.persist-db.browser :as browser]
+            [frontend.search.protocol :as protocol]
+            [frontend.state :as state]
+            [logseq.db :as ldb]
+            [promesa.core :as p]))
 
-(defonce *sqlite browser/*worker)
+(defonce *worker browser/*worker)
 
 (defrecord Browser [repo]
   protocol/Engine
   (query [_this q option]
-    (if-let [^js sqlite @*sqlite]
-      (p/let [result (.search-blocks sqlite (state/get-current-repo) q (bean/->js option))]
+    (if-let [worker @*worker]
+      (p/let [result (worker :search/search-blocks (state/get-current-repo) q (bean/->js option))]
         (ldb/read-transit-str result))
       (p/resolved nil)))
   (rebuild-pages-indice! [_this]
-    (if-let [^js sqlite @*sqlite]
-      (.search-build-pages-indice sqlite repo)
+    (if-let [worker @*worker]
+      (worker :search/build-pages-indice repo)
       (p/resolved nil)))
   (rebuild-blocks-indice! [this]
-    (if-let [^js sqlite @*sqlite]
+    (if-let [worker @*worker]
       (p/let [repo (state/get-current-repo)
               file-based? (config/local-file-based-graph? repo)
               _ (protocol/truncate-blocks! this)
-              result (.search-build-blocks-indice sqlite repo)
+              result (worker :search/build-blocks-indice repo)
               blocks (if file-based?
                        (->> (bean/->clj result)
                             ;; remove built-in properties from content
@@ -37,20 +37,20 @@
                             bean/->js)
                        result)
               _ (when (seq blocks)
-                  (.search-upsert-blocks sqlite repo blocks))])
+                  (worker :search/upsert-blocks repo blocks))])
       (p/resolved nil)))
   (transact-blocks! [_this {:keys [blocks-to-remove-set
                                    blocks-to-add]}]
-    (if-let [^js sqlite @*sqlite]
+    (if-let [worker @*worker]
       (let [repo (state/get-current-repo)]
         (p/let [_ (when (seq blocks-to-remove-set)
-                    (.search-delete-blocks sqlite repo (bean/->js blocks-to-remove-set)))]
+                    (worker :search/delete-blocks repo (bean/->js blocks-to-remove-set)))]
           (when (seq blocks-to-add)
-            (.search-upsert-blocks sqlite repo (bean/->js blocks-to-add)))))
+            (worker :search/upsert-blocks repo (bean/->js blocks-to-add)))))
       (p/resolved nil)))
   (truncate-blocks! [_this]
-    (if-let [^js sqlite @*sqlite]
-      (.search-truncate-tables sqlite (state/get-current-repo))
+    (if-let [worker @*worker]
+      (worker :search/truncate-tables (state/get-current-repo))
       (p/resolved nil)))
   (remove-db! [_this]
     ;; Already removed in OPFS

src/main/frontend/worker/db_listener.cljs

@@ -2,6 +2,7 @@
   "Db listeners for worker-db."
   (:require [cljs-bean.core :as bean]
             [datascript.core :as d]
+            [frontend.common.thread-api :as thread-api]
             [frontend.worker.pipeline :as worker-pipeline]
             [frontend.worker.search :as search]
             [frontend.worker.state :as worker-state]
@@ -30,13 +31,11 @@
 
       (when-not from-disk?
         (p/do!
-         (let [{:keys [blocks-to-remove-set blocks-to-add]} (search/sync-search-indice repo tx-report')
-               ^js wo (worker-state/get-worker-object)]
-           (when wo
-             (when (seq blocks-to-remove-set)
-               (.search-delete-blocks wo repo (bean/->js blocks-to-remove-set)))
-             (when (seq blocks-to-add)
-               (.search-upsert-blocks wo repo (bean/->js blocks-to-add))))))))
+         (let [{:keys [blocks-to-remove-set blocks-to-add]} (search/sync-search-indice repo tx-report')]
+           (when (seq blocks-to-remove-set)
+             ((@thread-api/*thread-apis :search/delete-blocks) repo (bean/->js blocks-to-remove-set)))
+           (when (seq blocks-to-add)
+             ((@thread-api/*thread-apis :search/upsert-blocks) repo (bean/->js blocks-to-add)))))))
     tx-report'))
 
 (comment

src/main/frontend/worker/db_metadata.cljs

@@ -1,7 +1,6 @@
 (ns frontend.worker.db-metadata
   "Fns to read/write metadata.edn file for db-based."
-  (:require [frontend.common.thread-api :refer [def-thread-api]]
-            [frontend.worker.util :as worker-util]
+  (:require [frontend.worker.util :as worker-util]
             [promesa.core :as p]))
 
 (defn <store
@@ -12,7 +11,3 @@
           writable (.createWritable file-handle)
           _ (.write writable metadata-str)]
     (.close writable)))
-
-(def-thread-api :db-metadata/store
-  [repo metadata-str]
-  (<store repo metadata-str))

src/main/frontend/worker/db_worker.cljs

@@ -9,7 +9,7 @@
             [datascript.core :as d]
             [datascript.storage :refer [IStorage] :as storage]
             [frontend.common.file.core :as common-file]
-            [frontend.common.thread-api :refer [def-thread-api]]
+            [frontend.common.thread-api :as thread-api :refer [def-thread-api]]
             [frontend.worker.crypt :as worker-crypt]
             [frontend.worker.db-listener :as db-listener]
             [frontend.worker.db-metadata :as worker-db-metadata]
@@ -29,6 +29,7 @@
             [frontend.worker.undo-redo2 :as undo-redo]
             [frontend.worker.util :as worker-util]
             [goog.object :as gobj]
+            [lambdaisland.glogi :as log]
             [lambdaisland.glogi.console :as glogi-console]
             [logseq.common.config :as common-config]
             [logseq.common.util :as common-util]
@@ -424,9 +425,10 @@
                       {:name graph-name
                        :metadata (edn/read-string metadata)})) db-dirs)))))
 
-(def-thread-api :general/list-all-dbs
+(def-thread-api :general/list-db
   []
-  (<list-all-dbs))
+  (p/let [dbs (<list-all-dbs)]
+    (ldb/write-transit-str dbs)))
 
 (defn- <db-exists?
   [graph]
@@ -462,6 +464,7 @@
 
 (def-thread-api :general/init
   [rtc-ws-url]
+  (prn :debug/calling :general/init)
   (reset! worker-state/*rtc-ws-url rtc-ws-url)
   (init-sqlite-module!))
 
@@ -532,7 +535,7 @@
     nil))
 
 (def-thread-api :general/transact
-  [this repo tx-data tx-meta context]
+  [repo tx-data tx-meta context]
   (when repo (worker-state/set-db-latest-tx-time! repo))
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (try
@@ -760,487 +763,11 @@
 
 (comment
   (def-thread-api :general/dangerousRemoveAllDbs
-    [this repo]
-    (p/let [r (.listDB this)
+    []
+    (p/let [r (<list-all-dbs)
             dbs (ldb/read-transit-str r)]
       (p/all (map #(.unsafeUnlinkDB this (:name %)) dbs)))))
 
-#_:clj-kondo/ignore
-(defclass DBWorker
-  (extends js/Object)
-
-  (constructor
-   [this]
-   (super))
-
-  Object
-
-  (getVersion
-   [_this]
-   (when-let [sqlite @*sqlite]
-     (.-version sqlite)))
-
-  (init
-   [_this rtc-ws-url]
-   (reset! worker-state/*rtc-ws-url rtc-ws-url)
-   (init-sqlite-module!))
-
-  (storeMetadata
-   [_this repo metadata-str]
-   (worker-db-metadata/<store repo metadata-str))
-
-  (listDB
-   [_this]
-   (p/let [dbs (<list-all-dbs)]
-     (ldb/write-transit-str dbs)))
-
-  (createOrOpenDB
-   [_this repo opts-str]
-   (let [{:keys [close-other-db?] :or {close-other-db? true} :as opts} (ldb/read-transit-str opts-str)]
-     (p/do!
-      (when close-other-db?
-        (close-other-dbs! repo))
-      (create-or-open-db! repo (dissoc opts :close-other-db?)))))
-
-  (q [_this repo inputs-str]
-     "Datascript q"
-     (when-let [conn (worker-state/get-datascript-conn repo)]
-       (let [inputs (ldb/read-transit-str inputs-str)
-             result (apply d/q (first inputs) @conn (rest inputs))]
-         (ldb/write-transit-str result))))
-
-  (pull
-   [_this repo selector-str id-str]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [selector (ldb/read-transit-str selector-str)
-           id (ldb/read-transit-str id-str)
-           eid (if (and (vector? id) (= :block/name (first id)))
-                 (:db/id (ldb/get-page @conn (second id)))
-                 id)
-           result (some->> eid
-                           (d/pull @conn selector)
-                           (sqlite-common-db/with-parent @conn))]
-       (ldb/write-transit-str result))))
-
-  (pull-many
-   [_this repo selector-str ids-str]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [selector (ldb/read-transit-str selector-str)
-           ids (ldb/read-transit-str ids-str)
-           result (d/pull-many @conn selector ids)]
-       (ldb/write-transit-str result))))
-
-  (get-right-sibling
-   [_this repo db-id]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [result (ldb/get-right-sibling (d/entity @conn db-id))]
-       (ldb/write-transit-str result))))
-
-  (get-block-and-children
-   [_this repo id opts]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [id (if (and (string? id) (common-util/uuid-string? id)) (uuid id) id)]
-       (ldb/write-transit-str (sqlite-common-db/get-block-and-children @conn id (ldb/read-transit-str opts))))))
-
-  (get-block-refs
-   [_this repo id]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (ldb/get-block-refs @conn id))))
-
-  (get-block-refs-count
-   [_this repo id]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/get-block-refs-count @conn id)))
-
-  (get-block-parents
-   [_this repo id depth]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [block-id (:block/uuid (d/entity @conn id))
-           parents (->> (ldb/get-block-parents @conn block-id {:depth (or depth 3)})
-                        (map (fn [b] (d/pull @conn '[*] (:db/id b)))))]
-       (ldb/write-transit-str parents))))
-
-  (get-page-unlinked-refs
-   [_this repo page-id search-result-eids-str]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [search-result-eids (ldb/read-transit-str search-result-eids-str)]
-       (ldb/write-transit-str (ldb/get-page-unlinked-refs @conn page-id search-result-eids)))))
-
-  (set-context
-   [_this context]
-   (let [context (if (string? context)
-                   (ldb/read-transit-str context)
-                   context)]
-     (when context (worker-state/update-context! context))
-     nil))
-
-  (transact
-   [_this repo tx-data tx-meta context]
-   (when repo (worker-state/set-db-latest-tx-time! repo))
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (try
-       (let [tx-data' (if (string? tx-data)
-                        (ldb/read-transit-str tx-data)
-                        tx-data)
-             tx-meta (if (string? tx-meta)
-                       (ldb/read-transit-str tx-meta)
-                       tx-meta)
-             tx-data' (if (contains? #{:insert-blocks} (:outliner-op tx-meta))
-                        (map (fn [m]
-                               (if (and (map? m) (nil? (:block/order m)))
-                                 (assoc m :block/order (db-order/gen-key nil))
-                                 m)) tx-data')
-                        tx-data')
-             context (if (string? context)
-                       (ldb/read-transit-str context)
-                       context)
-             _ (when context (worker-state/set-context! context))
-             tx-meta' (cond-> tx-meta
-                        (and (not (:whiteboard/transact? tx-meta))
-                             (not (:rtc-download-graph? tx-meta))) ; delay writes to the disk
-                        (assoc :skip-store? true)
-
-                        true
-                        (dissoc :insert-blocks?))]
-         (when-not (and (:create-today-journal? tx-meta)
-                        (:today-journal-name tx-meta)
-                        (seq tx-data')
-                        (ldb/get-page @conn (:today-journal-name tx-meta))) ; today journal created already
-
-           ;; (prn :debug :transact :tx-data tx-data' :tx-meta tx-meta')
-
-           (worker-util/profile "Worker db transact"
-                                (ldb/transact! conn tx-data' tx-meta')))
-         nil)
-       (catch :default e
-         (prn :debug :error)
-         (let [tx-data (if (string? tx-data)
-                         (ldb/read-transit-str tx-data)
-                         tx-data)]
-           (js/console.error e)
-           (prn :debug :tx-data @conn tx-data))))))
-
-  (getInitialData
-   [_this repo]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (sqlite-common-db/get-initial-data @conn))))
-
-  (get-page-refs-count
-   [_this repo]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (sqlite-common-db/get-page->refs-count @conn))))
-
-  (fetch-all-pages
-   [_this repo exclude-page-ids-str]
-   ;; (when-let [conn (worker-state/get-datascript-conn repo)]
-   ;;   (async/go
-   ;;     (let [all-pages (sqlite-common-db/get-all-pages @conn (ldb/read-transit-str exclude-page-ids-str))
-   ;;           partitioned-data (map-indexed (fn [idx p] [idx p]) (partition-all 2000 all-pages))]
-   ;;       (doseq [[idx tx-data] partitioned-data]
-   ;;         (worker-util/post-message :sync-db-changes {:repo repo
-   ;;                                                     :tx-data tx-data
-   ;;                                                     :tx-meta {:initial-pages? true
-   ;;                                                               :end? (= idx (dec (count partitioned-data)))}})
-   ;;         (async/<! (async/timeout 100)))))
-   ;;   nil)
-   )
-
-  (closeDB
-   [_this repo]
-   (close-db! repo))
-
-  (resetDB
-   [_this repo db-transit]
-   (reset-db! repo db-transit))
-
-  (unsafeUnlinkDB
-   [_this repo]
-   (p/let [pool (<get-opfs-pool repo)
-           _ (close-db! repo)
-           result (remove-vfs! pool)]
-     nil))
-
-  (releaseAccessHandles
-   [_this repo]
-   (when-let [^js pool (worker-state/get-opfs-pool repo)]
-     (.releaseAccessHandles pool)))
-
-  (dbExists
-   [_this repo]
-   (<db-exists? repo))
-
-  (exportDB
-   [_this repo]
-   (when-let [^js db (worker-state/get-sqlite-conn repo :db)]
-     (.exec db "PRAGMA wal_checkpoint(2)"))
-   (<export-db-file repo))
-
-  (importDb
-   [this repo data]
-   (when-not (string/blank? repo)
-     (p/let [pool (<get-opfs-pool repo)]
-       (<import-db pool data))))
-
-  ;; Search
-  (search-blocks
-   [this repo q option]
-   (p/let [search-db (get-search-db repo)
-           conn (worker-state/get-datascript-conn repo)
-           result (search/search-blocks repo conn search-db q (bean/->clj option))]
-     (ldb/write-transit-str result)))
-
-  (search-upsert-blocks
-   [this repo blocks]
-   (p/let [db (get-search-db repo)]
-     (search/upsert-blocks! db blocks)
-     nil))
-
-  (search-delete-blocks
-   [this repo ids]
-   (p/let [db (get-search-db repo)]
-     (search/delete-blocks! db ids)
-     nil))
-
-  (search-truncate-tables
-   [this repo]
-   (p/let [db (get-search-db repo)]
-     (search/truncate-table! db)
-     nil))
-
-  (search-build-blocks-indice
-   [this repo]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (search/build-blocks-indice repo @conn)))
-
-  (search-build-pages-indice
-   [this repo]
-   nil)
-
-  (apply-outliner-ops
-   [this repo ops-str opts-str]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (try
-       (worker-util/profile
-        "apply outliner ops"
-        (let [ops (ldb/read-transit-str ops-str)
-              opts (ldb/read-transit-str opts-str)
-              result (outliner-op/apply-ops! repo conn ops (worker-state/get-date-formatter repo) opts)]
-          (ldb/write-transit-str result)))
-       (catch :default e
-         (let [data (ex-data e)
-               {:keys [type payload]} (when (map? data) data)]
-           (case type
-             :notification
-             (worker-util/post-message type [(:message payload) (:type payload)])
-             (throw e)))))))
-
-  (file-writes-finished?
-   [this repo]
-   (let [conn (worker-state/get-datascript-conn repo)
-         writes @file/*writes]
-     ;; Clean pages that have been deleted
-     (when conn
-       (swap! file/*writes (fn [writes]
-                             (->> writes
-                                  (remove (fn [[_ pid]] (d/entity @conn pid)))
-                                  (into {})))))
-     (if (empty? writes)
-       true
-       (do
-         (prn "Unfinished file writes:" @file/*writes)
-         false))))
-
-  (page-file-saved
-   [this request-id page-id]
-   (file/dissoc-request! request-id)
-   nil)
-
-  (sync-app-state
-   [this new-state-str]
-   (let [new-state (ldb/read-transit-str new-state-str)]
-     (worker-state/set-new-state! new-state)
-     nil))
-
-  (sync-ui-state
-   [_this repo state-str]
-   (undo-redo/record-ui-state! repo state-str)
-   nil)
-
-  ;; Export
-  (block->content
-   [this repo block-uuid-str tree->file-opts context]
-   (assert (common-util/uuid-string? block-uuid-str))
-   (let [block-uuid (uuid block-uuid-str)]
-     (when-let [conn (worker-state/get-datascript-conn repo)]
-       (common-file/block->content repo @conn block-uuid
-                                   (ldb/read-transit-str tree->file-opts)
-                                   (ldb/read-transit-str context)))))
-
-  (get-debug-datoms
-   [this repo]
-   (when-let [db (worker-state/get-sqlite-conn repo)]
-     (let [conn (worker-state/get-datascript-conn repo)]
-       (ldb/write-transit-str (worker-export/get-debug-datoms conn db)))))
-
-  (get-all-pages
-   [this repo]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (worker-export/get-all-pages repo @conn))))
-
-  (get-all-page->content
-   [this repo]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (worker-export/get-all-page->content repo @conn))))
-
-  ;; RTC
-  (rtc-start
-   [this repo token]
-   (with-write-transit-str
-     (rtc-core/new-task--rtc-start repo token)))
-
-  (rtc-stop
-   [this]
-   (rtc-core/rtc-stop))
-
-  (rtc-toggle-auto-push
-   [this]
-   (rtc-core/rtc-toggle-auto-push))
-
-  (rtc-toggle-remote-profile
-   [this]
-   (rtc-core/rtc-toggle-remote-profile))
-
-  (rtc-grant-graph-access
-   [this token graph-uuid target-user-uuids-str target-user-emails-str]
-   (let [target-user-uuids (ldb/read-transit-str target-user-uuids-str)
-         target-user-emails (ldb/read-transit-str target-user-emails-str)]
-     (with-write-transit-str
-       (rtc-core/new-task--grant-access-to-others token graph-uuid
-                                                  :target-user-uuids target-user-uuids
-                                                  :target-user-emails target-user-emails))))
-
-  (rtc-get-graphs
-   [this token]
-   (with-write-transit-str
-     (rtc-core/new-task--get-graphs token)))
-
-  (rtc-delete-graph
-   [this token graph-uuid schema-version]
-   (with-write-transit-str
-     (rtc-core/new-task--delete-graph token graph-uuid schema-version)))
-
-  (rtc-get-users-info
-   [this token graph-uuid]
-   (with-write-transit-str
-     (rtc-core/new-task--get-users-info token graph-uuid)))
-
-  (rtc-get-block-content-versions
-   [this token graph-uuid block-uuid]
-   (with-write-transit-str
-     (rtc-core/new-task--get-block-content-versions token graph-uuid block-uuid)))
-
-  (rtc-get-debug-state
-   [this]
-   (with-write-transit-str
-     (rtc-core/new-task--get-debug-state)))
-
-  (rtc-async-upload-graph
-   [this repo token remote-graph-name]
-   (with-write-transit-str
-     (rtc-core/new-task--upload-graph token repo remote-graph-name)))
-
-  (rtc-async-branch-graph
-   [this repo token]
-   (with-write-transit-str
-     (rtc-core/new-task--branch-graph token repo)))
-
-  (rtc-request-download-graph
-   [this token graph-uuid schema-version]
-   (with-write-transit-str
-     (rtc-core/new-task--request-download-graph token graph-uuid schema-version)))
-
-  (rtc-wait-download-graph-info-ready
-   [this token download-info-uuid graph-uuid schema-version timeout-ms]
-   (with-write-transit-str
-     (rtc-core/new-task--wait-download-info-ready token download-info-uuid graph-uuid schema-version timeout-ms)))
-
-  (rtc-download-graph-from-s3
-   [this graph-uuid graph-name s3-url]
-   (with-write-transit-str
-     (rtc-core/new-task--download-graph-from-s3 graph-uuid graph-name s3-url)))
-
-  (rtc-download-info-list
-   [this token graph-uuid schema-version]
-   (with-write-transit-str
-     (rtc-core/new-task--download-info-list token graph-uuid schema-version)))
-
-  (rtc-get-graph-keys
-   [this repo]
-   (with-write-transit-str
-     (worker-crypt/get-graph-keys-jwk repo)))
-
-  (rtc-sync-current-graph-encrypted-aes-key
-   [this token device-uuids-transit-str]
-   (with-write-transit-str
-     (worker-device/new-task--sync-current-graph-encrypted-aes-key
-      token device-uuids-transit-str)))
-
-  (device-list-devices
-   [this token]
-   (with-write-transit-str
-     (worker-device/new-task--list-devices token)))
-
-  (device-remove-device-public-key
-   [this token device-uuid key-name]
-   (with-write-transit-str
-     (worker-device/new-task--remove-device-public-key token device-uuid key-name)))
-
-  (device-remove-device
-   [this token device-uuid]
-   (with-write-transit-str
-     (worker-device/new-task--remove-device token device-uuid)))
-
-  (undo
-   [_this repo _page-block-uuid-str]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (undo-redo/undo repo conn))))
-
-  (redo
-   [_this repo _page-block-uuid-str]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (ldb/write-transit-str (undo-redo/redo repo conn))))
-
-  (record-editor-info
-   [_this repo _page-block-uuid-str editor-info-str]
-   (undo-redo/record-editor-info! repo (ldb/read-transit-str editor-info-str))
-   nil)
-
-  (validate-db
-   [_this repo]
-   (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [result (worker-db-validate/validate-db @conn)]
-       (db-migrate/fix-db! conn {:invalid-entity-ids (:invalid-entity-ids result)})
-       result)))
-
-  (export-edn
-   [_this repo options]
-   (let [conn (worker-state/get-datascript-conn repo)]
-     (try
-       (->> (ldb/read-transit-str options)
-            (sqlite-export/build-export @conn)
-            ldb/write-transit-str)
-       (catch :default e
-         (js/console.error "export-edn error: " e)
-         (worker-util/post-message :notification
-                                   ["An unexpected error occurred during export. See the javascript console for details."
-                                    :error])))))
-
-  (dangerousRemoveAllDbs
-   [this repo]
-   (p/let [r (.listDB this)
-           dbs (ldb/read-transit-str r)]
-     (p/all (map #(.unsafeUnlinkDB this (:name %)) dbs)))))
-
 (defn- rename-page!
   [repo conn page-uuid new-name]
   (let [config (worker-state/get-config repo)
@@ -1283,18 +810,25 @@
              (file/write-files! conn col (worker-state/get-context)))
            (js/console.error (str "DB is not found for " repo))))))))
 
+(defn- remote-function
+  [qkw-str args-transit-str]
+  (let [qkw (keyword qkw-str)]
+    (if-let [f (@thread-api/*thread-apis qkw)]
+      (apply f (ldb/read-transit-str args-transit-str))
+      (throw (ex-info (str "not found thread-api: " qkw-str) {})))))
+
 (defn init
   "web worker entry"
   []
   (glogi-console/install!)
   (check-worker-scope!)
-  (let [^js obj (DBWorker.)]
-    (outliner-register-op-handlers!)
-    (worker-state/set-worker-object! obj)
-    (<ratelimit-file-writes!)
-    (js/setInterval #(.postMessage js/self "keepAliveResponse") (* 1000 25))
-    (Comlink/expose obj)
-    (reset! worker-state/*main-thread (Comlink/wrap js/self))))
+  (outliner-register-op-handlers!)
+  (worker-state/set-worker-object! 11111)
+  (<ratelimit-file-writes!)
+  (js/setInterval #(.postMessage js/self "keepAliveResponse") (* 1000 25))
+    ;; (Comlink/expose obj)
+  (Comlink/expose #js{"remoteInvoke" remote-function})
+  (reset! worker-state/*main-thread (Comlink/wrap js/self)))
 
 (comment
   (defn <remove-all-files!

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

@@ -5,8 +5,10 @@
             [clojure.set :as set]
             [datascript.core :as d]
             [frontend.common.missionary :as c.m]
+            [frontend.common.thread-api :as thread-api]
             [frontend.worker.crypt :as crypt]
             [frontend.worker.db-listener :as db-listener]
+            [frontend.worker.db-metadata :as worker-db-metadata]
             [frontend.worker.rtc.client-op :as client-op]
             [frontend.worker.rtc.const :as rtc-const]
             [frontend.worker.rtc.log-and-state :as rtc-log-and-state]
@@ -164,8 +166,7 @@
             (client-op/add-all-exists-asset-as-ops repo)
             (crypt/store-graph-keys-jwk repo aes-key-jwk)
             (when-not rtc-const/RTC-E2E-TEST
-              (let [^js worker-obj (:worker/object @worker-state/*state)]
-                (c.m/<? (.storeMetadata worker-obj repo (pr-str {:kv/value graph-uuid})))))
+              (c.m/<? (worker-db-metadata/<store repo (pr-str {:kv/value graph-uuid}))))
             (rtc-log-and-state/rtc-log :rtc.log/upload {:sub-type :upload-completed
                                                         :message "upload-graph completed"})
             {:graph-uuid graph-uuid})
@@ -348,7 +349,7 @@
                  (blocks-resolve-temp-id normal-blocks)
                  [(ldb/kv :logseq.kv/graph-uuid graph-uuid)])
         init-tx-data (cons (ldb/kv :logseq.kv/db-type "db") schema-blocks)
-        ^js worker-obj (:worker/object @worker-state/*state)]
+        worker-obj (:worker/object @worker-state/*state)]
     (m/sp
       (client-op/update-local-tx repo t)
       (rtc-log-and-state/update-local-t graph-uuid t)
@@ -357,16 +358,20 @@
         (create-graph-for-rtc-test repo init-tx-data tx-data)
         (c.m/<?
          (p/do!
-          (.createOrOpenDB worker-obj repo (ldb/write-transit-str {:close-other-db? false}))
-          (.exportDB worker-obj repo)
-          (.transact worker-obj repo init-tx-data {:rtc-download-graph? true
-                                                   :gen-undo-ops? false
-                                                    ;; only transact db schema, skip validation to avoid warning
-                                                   :frontend.worker.pipeline/skip-validate-db? true
-                                                   :persist-op? false} (worker-state/get-context))
-          (.transact worker-obj repo tx-data {:rtc-download-graph? true
-                                              :gen-undo-ops? false
-                                              :persist-op? false} (worker-state/get-context))
+          ((@thread-api/*thread-apis :general/create-or-open-db) repo (ldb/write-transit-str {:close-other-db? false}))
+          ((@thread-api/*thread-apis :general/export-db) repo)
+          ((@thread-api/*thread-apis :general/transact)
+           repo init-tx-data
+           {:rtc-download-graph? true
+            :gen-undo-ops? false
+            ;; only transact db schema, skip validation to avoid warning
+            :frontend.worker.pipeline/skip-validate-db? true
+            :persist-op? false}
+           (worker-state/get-context))
+          ((@thread-api/*thread-apis :general/transact)
+           repo tx-data {:rtc-download-graph? true
+                         :gen-undo-ops? false
+                         :persist-op? false} (worker-state/get-context))
           (transact-remote-schema-version! repo)
           (transact-block-refs! repo))))
       (worker-util/post-message :add-repo {:repo repo}))))
@@ -423,8 +428,7 @@
     (rtc-log-and-state/rtc-log :rtc.log/download {:sub-type :downloading-graph-data
                                                   :message "downloading graph data"
                                                   :graph-uuid graph-uuid})
-    (let [^js worker-obj              (:worker/object @worker-state/*state)
-          {:keys [status body] :as r} (m/? (http/get s3-url {:with-credentials? false}))
+    (let [{:keys [status body] :as r} (m/? (http/get s3-url {:with-credentials? false}))
           repo                        (str sqlite-util/db-version-prefix graph-name)]
       (if (not= 200 status)
         (throw (ex-info "download-graph from s3 failed" {:resp r}))
@@ -437,7 +441,7 @@
             (m/? (new-task--transact-remote-all-blocks all-blocks repo graph-uuid))
             (client-op/update-graph-uuid repo graph-uuid)
             (when-not rtc-const/RTC-E2E-TEST
-              (c.m/<? (.storeMetadata worker-obj repo (pr-str {:kv/value graph-uuid}))))
+              (c.m/<? (worker-db-metadata/<store repo (pr-str {:kv/value graph-uuid}))))
             (worker-state/set-rtc-downloading-graph! false)
             (rtc-log-and-state/rtc-log :rtc.log/download {:sub-type :download-completed
                                                           :message "download completed"
@@ -482,8 +486,7 @@
             (client-op/remove-local-tx repo)
             (client-op/add-all-exists-asset-as-ops repo)
             (crypt/store-graph-keys-jwk repo aes-key-jwk)
-            (let [^js worker-obj (:worker/object @worker-state/*state)]
-              (c.m/<? (.storeMetadata worker-obj repo (pr-str {:kv/value graph-uuid}))))
+            (c.m/<? (worker-db-metadata/<store repo (pr-str {:kv/value graph-uuid})))
             (rtc-log-and-state/rtc-log :rtc.log/branch-graph {:sub-type :completed
                                                               :message "branch-graph completed"})
             nil)