refactor: unify the transit-read/write for the return values of the thread-api

src/main/frontend/common/thread_api.cljc

@@ -1,6 +1,8 @@
 (ns frontend.common.thread-api
   "Macro for defining thread apis, which is invokeable by other threads"
-  #?(:cljs (:require-macros [frontend.common.thread-api])))
+  #?(:cljs (:require-macros [frontend.common.thread-api]))
+  #?(:cljs (:require [logseq.db :as ldb]
+                     [promesa.core :as p])))
 
 #?(:cljs
    (def *thread-apis (volatile! {})))
@@ -17,3 +19,19 @@ e.g. (def-thread-api :rtc/a-api [arg1 arg2] body)"
   `(vswap! *thread-apis assoc
            ~qualified-keyword-name
            (fn ~params ~@body)))
+
+#?(:cljs
+   (defn remote-function
+     "Return a promise whose value is transit-str."
+     [qualified-kw-str args-transit-str]
+     (let [qkw (keyword qualified-kw-str)]
+       (if-let [f (@*thread-apis qkw)]
+         (let [result (apply f (ldb/read-transit-str args-transit-str))
+               result-promise
+               (if (fn? result) ;; missionary task is a fn
+                 (js/Promise. result)
+                 result)]
+           (p/chain
+            result-promise
+            ldb/write-transit-str))
+         (throw (ex-info (str "not found thread-api: " qualified-kw-str) {}))))))

src/main/frontend/components/all_pages.cljs

@@ -51,8 +51,7 @@
     (hooks/use-effect!
      (fn []
        (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)
+         (p/let [result (worker :general/get-page-refs-count (state/get-current-repo))
                  data (get-all-pages)
                  data (map (fn [row] (assoc row :block.temp/refs-count (get result (:db/id row) 0))) data)]
            (set-data! data))))

src/main/frontend/components/content.cljs

@@ -357,8 +357,7 @@
                   (let [worker @db-browser/*worker
                         token (state/get-auth-id-token)
                         graph-uuid (ldb/get-graph-rtc-uuid (db/get-db))]
-                    (p/let [result (worker :rtc/get-block-content-versions token graph-uuid (str block-id))
-                            blocks-versions (ldb/read-transit-str result)]
+                    (p/let [blocks-versions (worker :rtc/get-block-content-versions token graph-uuid (str block-id))]
                       (prn :Dev-show-block-content-history)
                       (doseq [[block-uuid versions] blocks-versions]
                         (prn :block-uuid block-uuid)

src/main/frontend/db/async.cljs

@@ -150,10 +150,10 @@
       (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 (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)
+        (p/let [{:keys [properties block children] :as result'}
+                (worker :general/get-block-and-children graph id (ldb/write-transit-str
+                                                                  {:children? children?
+                                                                   :nested-children? nested-children?}))
                 conn (db/get-db graph false)
                 block-and-children (concat properties [block] children)
                 _ (d/transact! conn block-and-children)
@@ -171,8 +171,7 @@
   (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 (worker :general/get-block-parents graph id depth)
-              result (ldb/read-transit-str result-str)
+      (p/let [result (worker :general/get-block-parents graph id depth)
               conn (db/get-db graph false)
               _ (d/transact! conn result)]
         (state/update-state! :db/async-query-loading (fn [s] (disj s (str block-id "-parents"))))
@@ -188,15 +187,14 @@
                              (ldb/write-transit-str
                               {:children? true
                                :nested-children? false}))]
-        (some-> result (ldb/read-transit-str) (:children))))))
+        (:children result)))))
 
 (defn <get-block-refs
   [graph eid]
   (assert (integer? eid))
   (when-let [worker @db-browser/*worker]
     (state/update-state! :db/async-query-loading (fn [s] (conj s (str eid "-refs"))))
-    (p/let [result-str (worker :general/get-block-refs graph eid)
-            result (ldb/read-transit-str result-str)
+    (p/let [result (worker :general/get-block-refs graph eid)
             conn (db/get-db graph false)
             _ (d/transact! conn result)]
       (state/update-state! :db/async-query-loading (fn [s] (disj s (str eid "-refs"))))

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

@@ -1,10 +1,10 @@
 (ns frontend.db.async.util
   "Async util helper"
-  (:require [frontend.state :as state]
-            [promesa.core :as p]
+  (:require [datascript.core :as d]
             [frontend.db.conn :as db-conn]
-            [datascript.core :as d]
-            [logseq.db :as ldb]))
+            [frontend.state :as state]
+            [logseq.db :as ldb]
+            [promesa.core :as p]))
 
 (defn <q
   [graph {:keys [transact-db?]
@@ -20,32 +20,30 @@
         (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)]
-              (when (and transact-db? (seq result') (coll? result'))
-                (when-let [conn (db-conn/get-db graph false)]
-                  (let [tx-data (->>
-                                 (if (and (coll? (first result'))
-                                          (not (map? (first result'))))
-                                   (apply concat result')
-                                   result')
-                                 (remove nil?))]
-                    (if (every? map? tx-data)
-                      (try
-                        (d/transact! conn tx-data)
-                        (catch :default e
-                          (js/console.error "<q failed with:" e)
-                          nil))
-                      (js/console.log "<q skipped tx for inputs:" inputs)))))
-              result')))))))
+            (when (and transact-db? (seq result) (coll? result))
+              (when-let [conn (db-conn/get-db graph false)]
+                (let [tx-data (->>
+                               (if (and (coll? (first result))
+                                        (not (map? (first result))))
+                                 (apply concat result)
+                                 result)
+                               (remove nil?))]
+                  (if (every? map? tx-data)
+                    (try
+                      (d/transact! conn tx-data)
+                      (catch :default e
+                        (js/console.error "<q failed with:" e)
+                        nil))
+                    (js/console.log "<q skipped tx for inputs:" inputs)))))
+            result))))))
 
 (defn <pull
   ([graph id]
    (<pull graph '[*] id))
   ([graph selector 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'))))))
+     (p/let [result' (worker :general/pull graph (ldb/write-transit-str selector) (ldb/write-transit-str id))]
+       (when result'
+         (when-let [conn (db-conn/get-db graph false)]
+           (d/transact! conn [result']))
+         result')))))

src/main/frontend/db/restore.cljs

@@ -1,7 +1,6 @@
 (ns frontend.db.restore
   "Fns for DB restore(from text or sqlite)"
   (:require [cljs-time.core :as t]
-            [datascript.transit :as dt]
             [frontend.db.conn :as db-conn]
             [frontend.persist-db :as persist-db]
             [frontend.state :as state]
@@ -13,9 +12,8 @@
   [repo & {:as opts}]
   (state/set-state! :graph/loading? true)
   (p/let [start-time (t/now)
-          data (persist-db/<fetch-init-data repo opts)
+          {:keys [schema initial-data] :as data} (persist-db/<fetch-init-data repo opts)
           _ (assert (some? data) "No data found when reloading db")
-          {:keys [schema initial-data]} (dt/read-transit-str data)
           conn (try
                  (sqlite-common-db/restore-initial-data initial-data schema)
                  (catch :default e

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

@@ -61,8 +61,7 @@
        {:size :sm
         :on-click (fn [_]
                     (let [worker @db-browser/*worker]
-                      (p/let [result (worker :rtc/get-debug-state)
-                              new-state (ldb/read-transit-str result)]
+                      (p/let [new-state (worker :rtc/get-debug-state)]
                         (swap! debug-state (fn [old] (merge old new-state))))))}
        (shui/tabler-icon "refresh") "state")
 
@@ -72,8 +71,7 @@
         (fn [_]
           (let [token (state/get-auth-id-token)
                 worker @db-browser/*worker]
-            (p/let [result (worker :rtc/get-graphs token)
-                    graph-list (ldb/read-transit-str result)]
+            (p/let [graph-list (worker :rtc/get-graphs token)]
               (swap! debug-state assoc
                      :remote-graphs
                      (map
@@ -188,15 +186,14 @@
                                     (p/let [token (state/get-auth-id-token)
                                             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 (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
                                                     _download-info-t
                                                     _download-info-created-at]
-                                             :as result} (ldb/read-transit-str result)]
+                                             :as result}
+                                            (worker :rtc/wait-download-graph-info-ready
+                                                    token download-info-uuid graph-uuid graph-schema-version 60000)]
                                       (when (not= result :timeout)
                                         (assert (some? download-info-s3-url) result)
                                         (worker :rtc/download-graph-from-s3
@@ -281,10 +278,8 @@
           {:size :sm
            :on-click (fn [_]
                        (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) (worker :device/list-devices))
-                                 devices (ldb/read-transit-str result2)]
+                         (p/let [graph-keys (worker :rtc/get-graph-keys (state/get-current-repo))
+                                 devices (some->> (state/get-auth-id-token) (worker :device/list-devices))]
                            (swap! (get state ::keys-state) #(merge % graph-keys {:devices devices})))))}
           (shui/tabler-icon "refresh") "keys-state")]
         [:div.pb-4

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

@@ -15,10 +15,9 @@
   ;; Use editor state to locate most recent block
   (if-let [block-uuid (:block-id (first (state/get-editor-args)))]
     (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*)
+      (p/let [result (worker :general/export-edn
+                             (state/get-current-repo)
+                             (ldb/write-transit-str {:export-type :block :block-id [:block/uuid block-uuid]}))
               pull-data (with-out-str (pprint/pprint result))]
         (.writeText js/navigator.clipboard pull-data)
         (println pull-data)
@@ -28,10 +27,9 @@
 (defn export-view-nodes-data [nodes]
   (let [block-uuids (mapv #(vector :block/uuid (:block/uuid %)) nodes)]
     (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*)
+      (p/let [result (worker :general/export-edn
+                             (state/get-current-repo)
+                             (ldb/write-transit-str {:export-type :view-nodes :node-ids block-uuids}))
               pull-data (with-out-str (pprint/pprint result))]
         (.writeText js/navigator.clipboard pull-data)
         (println pull-data)
@@ -40,9 +38,8 @@
 (defn ^:export export-page-data []
   (if-let [page-id (page-util/get-current-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*)
+      (p/let [result (worker :general/export-edn
+                             (state/get-current-repo) (ldb/write-transit-str {:export-type :page :page-id page-id}))
               pull-data (with-out-str (pprint/pprint result))]
         (.writeText js/navigator.clipboard pull-data)
         (println pull-data)
@@ -51,9 +48,8 @@
 
 (defn ^:export export-graph-ontology-data []
   (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*)
+    (p/let [result (worker :general/export-edn
+                           (state/get-current-repo) (ldb/write-transit-str {:export-type :graph-ontology}))
             pull-data (with-out-str (pprint/pprint result))]
       (.writeText js/navigator.clipboard pull-data)
       (println pull-data)
@@ -63,11 +59,10 @@
 
 (defn- export-graph-edn-data []
   (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*)
+    (p/let [result (worker :general/export-edn
+                           (state/get-current-repo)
+                           (ldb/write-transit-str {:export-type :graph
+                                                   :graph-options {:include-timestamps? true}}))
             pull-data (with-out-str (pprint/pprint result))]
       pull-data)))
 

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

@@ -38,16 +38,15 @@
     (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* (worker :rtc/request-download-graph token graph-uuid graph-schema-version)
-            download-info-uuid (ldb/read-transit-str download-info-uuid*)
-            result (worker :rtc/wait-download-graph-info-ready
-                           token download-info-uuid graph-uuid graph-schema-version timeout-ms)
+            download-info-uuid (worker :rtc/request-download-graph token graph-uuid graph-schema-version)
             {:keys [_download-info-uuid
                     download-info-s3-url
                     _download-info-tx-instant
                     _download-info-t
                     _download-info-created-at]
-             :as result} (ldb/read-transit-str result)]
+             :as result}
+            (worker :rtc/wait-download-graph-info-ready
+                    token download-info-uuid graph-uuid graph-schema-version timeout-ms)]
       (->
        (when (not= result :timeout)
          (assert (some? download-info-s3-url) result)
@@ -65,8 +64,7 @@
   (when-let [worker @state/*db-worker]
     (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)
             token (state/get-auth-id-token)
-            result (worker :rtc/async-branch-graph repo token)
-            start-ex (ldb/read-transit-str result)]
+            start-ex (worker :rtc/async-branch-graph repo token)]
       (when-let [ex-data* (:ex-data start-ex)]
         (throw (ex-info (:ex-message start-ex) ex-data*))))))
 
@@ -105,8 +103,7 @@
        (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 (worker :rtc/start repo token)
-                 start-ex (ldb/read-transit-str result)
+         (p/let [start-ex (worker :rtc/start repo token)
                  ex-data* (:ex-data start-ex)
                  _ (case (:type ex-data*)
                      (:rtc.exception/not-rtc-graph
@@ -141,8 +138,7 @@
   (when-let [worker @state/*db-worker]
     (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)
             token (state/get-auth-id-token)
-            result (worker :rtc/get-graphs token)
-            graphs (ldb/read-transit-str result)
+            graphs (worker :rtc/get-graphs token)
             result (->> graphs
                         (remove (fn [graph] (= (:graph-status graph) "deleting")))
                         (mapv (fn [graph]
@@ -162,8 +158,7 @@
     (when-let [worker @state/*db-worker]
       (p/let [token (state/get-auth-id-token)
               repo (state/get-current-repo)
-              result (worker :rtc/get-users-info token (str graph-uuid))
-              result (ldb/read-transit-str result)]
+              result (worker :rtc/get-users-info token (str graph-uuid))]
         (state/set-state! :rtc/users-info {repo result})))))
 
 (defn <rtc-invite-email

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

@@ -191,8 +191,7 @@
 (defn <get-all-pages
   [repo]
   (when-let [worker @db-browser/*worker]
-    (p/let [result (worker :export/get-all-pages repo)]
-      (ldb/read-transit-str result))))
+    (worker :export/get-all-pages repo)))
 
 (defn <get-debug-datoms
   [repo]
@@ -202,8 +201,7 @@
 (defn <get-all-page->content
   [repo]
   (when-let [worker @db-browser/*worker]
-    (p/let [result (worker :export/get-all-page->content repo)]
-      (ldb/read-transit-str result))))
+    (worker :export/get-all-page->content repo)))
 
 (defn <get-file-contents
   [repo suffix]

src/main/frontend/persist_db/browser.cljs

@@ -122,9 +122,11 @@
           worker (js/Worker. (str worker-url "?electron=" (util/electron?) "&publishing=" config/publishing?))
           wrapped-worker* (Comlink/wrap worker)
           wrapped-worker (fn [qkw & args]
-                           (.remoteInvoke ^js wrapped-worker*
-                                          (str (namespace qkw) "/" (name qkw))
-                                          (ldb/write-transit-str args)))
+                           (p/chain
+                            (.remoteInvoke ^js wrapped-worker*
+                                           (str (namespace qkw) "/" (name qkw))
+                                           (ldb/write-transit-str args))
+                            ldb/read-transit-str))
           t1 (util/time-ms)]
       (Comlink/expose (Main.) worker)
       (worker-handler/handle-message! worker wrapped-worker*)
@@ -181,7 +183,6 @@
   (<list-db [_this]
     (when-let [worker @*worker]
       (-> (worker :general/list-db)
-          (p/then ldb/read-transit-str)
           (p/catch sqlite-error-handler))))
 
   (<unsafe-delete [_this repo]

src/main/frontend/search.cljs

@@ -127,9 +127,8 @@
                       (remove (fn [b] (= (:block/uuid b) (:block/uuid entity))))
                       (map (fn [b] [:block/uuid (:block/uuid b)])))
             result (when (seq 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'
+                     (@state/*db-worker :general/get-page-unlinked-refs repo (:db/id entity) (ldb/write-transit-str eids)))]
+      (when result (d/transact! (db/get-db repo false) result))
+      (some->> result
                db-model/sort-by-order-recursive
                db-utils/group-by-page))))

src/main/frontend/search/browser.cljs

@@ -6,7 +6,6 @@
             [frontend.persist-db.browser :as browser]
             [frontend.search.protocol :as protocol]
             [frontend.state :as state]
-            [logseq.db :as ldb]
             [promesa.core :as p]))
 
 (defonce *worker browser/*worker)
@@ -15,8 +14,7 @@
   protocol/Engine
   (query [_this q 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))
+      (worker :search/search-blocks (state/get-current-repo) q (bean/->js option))
       (p/resolved nil)))
   (rebuild-pages-indice! [_this]
     (if-let [worker @*worker]

src/main/frontend/worker/crypt.cljs

@@ -125,13 +125,6 @@
     (let [aes-key-datom (first (d/datoms @conn :avet :aes-key-jwk))]
       {:aes-key-jwk (:v aes-key-datom)})))
 
-(defn- with-write-transit-str
-  [task]
-  (p/chain
-   (js/Promise. task)
-   ldb/write-transit-str))
-
 (def-thread-api :rtc/get-graph-keys
   [repo]
-  (with-write-transit-str
-    (get-graph-keys-jwk repo)))
+  (get-graph-keys-jwk repo))

src/main/frontend/worker/db_worker.cljs

@@ -18,6 +18,7 @@
             [frontend.worker.handler.page.file-based.rename :as file-worker-page-rename]
             [frontend.worker.rtc.asset-db-listener]
             [frontend.worker.rtc.client-op :as client-op]
+            [frontend.worker.rtc.core]
             [frontend.worker.rtc.db-listener]
             [frontend.worker.search :as search]
             [frontend.worker.state :as worker-state] ;; [frontend.worker.undo-redo :as undo-redo]
@@ -284,8 +285,7 @@
                                          (set! (.-storage s) (.-storage (:eavt @conn)))
                                          s))]
       (d/reset-conn! conn new-db' {:reset-conn! true})
-      (d/reset-schema! conn (:schema new-db))
-      nil)))
+      (d/reset-schema! conn (:schema new-db)))))
 
 (defn- get-dbs
   [repo]
@@ -420,8 +420,7 @@
 
 (def-thread-api :general/list-db
   []
-  (p/let [dbs (<list-all-dbs)]
-    (ldb/write-transit-str dbs)))
+  (<list-all-dbs))
 
 (defn- <db-exists?
   [graph]
@@ -449,7 +448,6 @@
 
 (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!))
 
@@ -459,14 +457,14 @@
     (p/do!
      (when close-other-db?
        (close-other-dbs! repo))
-     (create-or-open-db! repo (dissoc opts :close-other-db?)))))
+     (create-or-open-db! repo (dissoc opts :close-other-db?))
+     nil)))
 
 (def-thread-api :general/q
   [repo inputs-str]
   (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))))
+    (let [inputs (ldb/read-transit-str inputs-str)]
+      (apply d/q (first inputs) @conn (rest inputs)))))
 
 (def-thread-api :general/pull
   [repo selector-str id-str]
@@ -475,22 +473,21 @@
           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))))
+                id)]
+      (some->> eid
+               (d/pull @conn selector)
+               (sqlite-common-db/with-parent @conn)))))
 
 (def-thread-api :general/get-block-and-children
   [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))))))
+      (sqlite-common-db/get-block-and-children @conn id (ldb/read-transit-str opts)))))
 
 (def-thread-api :general/get-block-refs
   [repo id]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (ldb/get-block-refs @conn id))))
+    (ldb/get-block-refs @conn id)))
 
 (def-thread-api :general/get-block-refs-count
   [repo id]
@@ -500,16 +497,15 @@
 (def-thread-api :general/get-block-parents
   [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))))
+    (let [block-id (:block/uuid (d/entity @conn id))]
+      (->> (ldb/get-block-parents @conn block-id {:depth (or depth 3)})
+           (map (fn [b] (d/pull @conn '[*] (:db/id b))))))))
 
 (def-thread-api :general/get-page-unlinked-refs
   [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)))))
+      (ldb/get-page-unlinked-refs @conn page-id search-result-eids))))
 
 (def-thread-api :general/set-context
   [context]
@@ -568,20 +564,22 @@
 (def-thread-api :general/get-initial-data
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (sqlite-common-db/get-initial-data @conn))))
+    (sqlite-common-db/get-initial-data @conn)))
 
 (def-thread-api :general/get-page-refs-count
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (sqlite-common-db/get-page->refs-count @conn))))
+    (sqlite-common-db/get-page->refs-count @conn)))
 
 (def-thread-api :general/close-db
   [repo]
-  (close-db! repo))
+  (close-db! repo)
+  nil)
 
 (def-thread-api :general/reset-db
   [repo db-transit]
-  (reset-db! repo db-transit))
+  (reset-db! repo db-transit)
+  nil)
 
 (def-thread-api :general/unsafe-unlink-db
   [repo]
@@ -593,7 +591,8 @@
 (def-thread-api :general/release-access-handles
   [repo]
   (when-let [^js pool (worker-state/get-opfs-pool repo)]
-    (.releaseAccessHandles pool)))
+    (.releaseAccessHandles pool)
+    nil))
 
 (def-thread-api :general/db-exists
   [repo]
@@ -609,14 +608,14 @@
   [repo data]
   (when-not (string/blank? repo)
     (p/let [pool (<get-opfs-pool repo)]
-      (<import-db pool data))))
+      (<import-db pool data)
+      nil)))
 
 (def-thread-api :search/search-blocks
   [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)))
+          conn (worker-state/get-datascript-conn repo)]
+    (search/search-blocks repo conn search-db q (bean/->clj option))))
 
 (def-thread-api :search/upsert-blocks
   [repo blocks]
@@ -652,9 +651,8 @@
       (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)))
+             opts (ldb/read-transit-str opts-str)]
+         (outliner-op/apply-ops! repo conn ops (worker-state/get-date-formatter repo) opts)))
       (catch :default e
         (let [data (ex-data e)
               {:keys [type payload]} (when (map? data) data)]
@@ -699,27 +697,27 @@
   [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)))))
+      (worker-export/get-debug-datoms conn db))))
 
 (def-thread-api :export/get-all-pages
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (worker-export/get-all-pages repo @conn))))
+    (worker-export/get-all-pages repo @conn)))
 
 (def-thread-api :export/get-all-page->content
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (worker-export/get-all-page->content repo @conn))))
+    (worker-export/get-all-page->content repo @conn)))
 
 (def-thread-api :undo-redo/undo
   [repo _page-block-uuid-str]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (undo-redo/undo repo conn))))
+    (undo-redo/undo repo conn)))
 
 (def-thread-api :undo-redo/redo
   [repo _page-block-uuid-str]
   (when-let [conn (worker-state/get-datascript-conn repo)]
-    (ldb/write-transit-str (undo-redo/redo repo conn))))
+    (undo-redo/redo repo conn)))
 
 (def-thread-api :undo-redo/record-editor-info
   [repo _page-block-uuid-str editor-info-str]
@@ -738,8 +736,7 @@
   (let [conn (worker-state/get-datascript-conn repo)]
     (try
       (->> (ldb/read-transit-str options)
-           (sqlite-export/build-export @conn)
-           ldb/write-transit-str)
+           (sqlite-export/build-export @conn))
       (catch :default e
         (js/console.error "export-edn error: " e)
         (worker-util/post-message :notification
@@ -795,13 +792,6 @@
              (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"
   []
@@ -810,8 +800,7 @@
   (outliner-register-op-handlers!)
   (<ratelimit-file-writes!)
   (js/setInterval #(.postMessage js/self "keepAliveResponse") (* 1000 25))
-    ;; (Comlink/expose obj)
-  (Comlink/expose #js{"remoteInvoke" remote-function})
+  (Comlink/expose #js{"remoteInvoke" thread-api/remote-function})
   (reset! worker-state/*main-thread (Comlink/wrap js/self)))
 
 (comment

src/main/frontend/worker/device.cljs

@@ -208,29 +208,18 @@
                 (m/? (new-task--sync-encrypted-aes-key*
                       get-ws-create-task device-uuid->encrypted-aes-key graph-uuid))))))))))
 
-(defn- with-write-transit-str
-  [task]
-  (p/chain
-   (js/Promise. task)
-   ldb/write-transit-str))
-
 (def-thread-api :rtc/sync-current-graph-encrypted-aes-key
   [token device-uuids-transit-str]
-  (with-write-transit-str
-    (new-task--sync-current-graph-encrypted-aes-key
-     token device-uuids-transit-str)))
+  (new-task--sync-current-graph-encrypted-aes-key token device-uuids-transit-str))
 
 (def-thread-api :device/list-devices
   [token]
-  (with-write-transit-str
-    (new-task--list-devices token)))
+  (new-task--list-devices token))
 
 (def-thread-api :device/remove-device-public-key
   [token device-uuid key-name]
-  (with-write-transit-str
-    (new-task--remove-device-public-key token device-uuid key-name)))
+  (new-task--remove-device-public-key token device-uuid key-name))
 
 (def-thread-api :device/remove-device
   [token device-uuid]
-  (with-write-transit-str
-    (new-task--remove-device token device-uuid)))
+  (new-task--remove-device token device-uuid))

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

@@ -24,8 +24,7 @@
             [logseq.db :as ldb]
             [logseq.db.frontend.schema :as db-schema]
             [malli.core :as ma]
-            [missionary.core :as m]
-            [promesa.core :as p])
+            [missionary.core :as m])
   (:import [missionary Cancelled]))
 
 (def ^:private rtc-state-schema
@@ -532,16 +531,9 @@
 
 (def new-task--download-graph-from-s3 r.upload-download/new-task--download-graph-from-s3)
 
-(defn- with-write-transit-str
-  [task]
-  (p/chain
-   (js/Promise. task)
-   ldb/write-transit-str))
-
 (def-thread-api :rtc/start
   [repo token]
-  (with-write-transit-str
-    (new-task--rtc-start repo token)))
+  (new-task--rtc-start repo token))
 
 (def-thread-api :rtc/stop
   []
@@ -559,65 +551,53 @@
   [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
-      (new-task--grant-access-to-others token graph-uuid
-                                        :target-user-uuids target-user-uuids
-                                        :target-user-emails target-user-emails))))
+    (new-task--grant-access-to-others token graph-uuid
+                                      :target-user-uuids target-user-uuids
+                                      :target-user-emails target-user-emails)))
 
 (def-thread-api :rtc/get-graphs
   [token]
-  (with-write-transit-str
-    (new-task--get-graphs token)))
+  (new-task--get-graphs token))
 
 (def-thread-api :rtc/delete-graph
   [token graph-uuid schema-version]
-  (with-write-transit-str
-    (new-task--delete-graph token graph-uuid schema-version)))
+  (new-task--delete-graph token graph-uuid schema-version))
 
 (def-thread-api :rtc/get-users-info
   [token graph-uuid]
-  (with-write-transit-str
-    (new-task--get-users-info token graph-uuid)))
+  (new-task--get-users-info token graph-uuid))
 
 (def-thread-api :rtc/get-block-content-versions
   [token graph-uuid block-uuid]
-  (with-write-transit-str
-    (new-task--get-block-content-versions token graph-uuid block-uuid)))
+  (new-task--get-block-content-versions token graph-uuid block-uuid))
 
 (def-thread-api :rtc/get-debug-state
   []
-  (with-write-transit-str
-    (new-task--get-debug-state)))
+  (new-task--get-debug-state))
 
 (def-thread-api :rtc/async-upload-graph
   [repo token remote-graph-name]
-  (with-write-transit-str
-    (new-task--upload-graph token repo remote-graph-name)))
+  (new-task--upload-graph token repo remote-graph-name))
 
 (def-thread-api :rtc/async-branch-graph
   [repo token]
-  (with-write-transit-str
-    (new-task--branch-graph token repo)))
+  (new-task--branch-graph token repo))
 
 (def-thread-api :rtc/request-download-graph
   [token graph-uuid schema-version]
-  (with-write-transit-str
-    (new-task--request-download-graph token graph-uuid schema-version)))
+  (new-task--request-download-graph token graph-uuid schema-version))
 
 (def-thread-api :rtc/wait-download-graph-info-ready
   [token download-info-uuid graph-uuid schema-version timeout-ms]
-  (with-write-transit-str
-    (new-task--wait-download-info-ready token download-info-uuid graph-uuid schema-version timeout-ms)))
+  (new-task--wait-download-info-ready token download-info-uuid graph-uuid schema-version timeout-ms))
 
 (def-thread-api :rtc/download-graph-from-s3
   [graph-uuid graph-name s3-url]
-  (with-write-transit-str
-    (new-task--download-graph-from-s3 graph-uuid graph-name s3-url)))
+  (new-task--download-graph-from-s3 graph-uuid graph-name s3-url))
 
 (def-thread-api :rtc/download-info-list
-  [ token graph-uuid schema-version]
-   (with-write-transit-str
-     (new-task--download-info-list token graph-uuid schema-version)))
+  [token graph-uuid schema-version]
+  (new-task--download-info-list token graph-uuid schema-version))
 
 ;;; ================ API (ends) ================