refactor: use the namespace "thread-api" for all thread-api keywords

src/main/frontend/common/thread_api.cljc

@@ -12,9 +12,9 @@
 
 (defmacro def-thread-api
   "Define a api invokeable by other threads.
-e.g. (def-thread-api :rtc/a-api [arg1 arg2] body)"
+e.g. (def-thread-api :thread-api/a-api [arg1 arg2] body)"
   [qualified-keyword-name params & body]
-  (assert (qualified-keyword? qualified-keyword-name) qualified-keyword-name)
+  (assert (= "thread-api" (namespace qualified-keyword-name)) qualified-keyword-name)
   (assert (vector? params) params)
   `(vswap! *thread-apis assoc
            ~qualified-keyword-name

src/main/frontend/components/all_pages.cljs

@@ -50,7 +50,7 @@
     (hooks/use-effect!
      (fn []
        (when-let [worker @state/*db-worker]
-         (p/let [result (worker :general/get-page-refs-count (state/get-current-repo))
+         (p/let [result (worker :thread-api/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,7 +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 [blocks-versions (worker :rtc/get-block-content-versions token graph-uuid block-id)]
+                    (p/let [blocks-versions (worker :thread-api/rtc-get-block-content-versions token graph-uuid 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

@@ -151,7 +151,7 @@
         (swap! *async-queries assoc [name' opts] true)
         (state/update-state! :db/async-query-loading (fn [s] (conj s name')))
         (p/let [{:keys [properties block children] :as result'}
-                (worker :general/get-block-and-children graph id {:children? children?
+                (worker :thread-api/get-block-and-children graph id {:children? children?
                                                                   :nested-children? nested-children?})
                 conn (db/get-db graph false)
                 block-and-children (concat properties [block] children)
@@ -170,7 +170,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 (worker :general/get-block-parents graph id depth)
+      (p/let [result (worker :thread-api/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"))))
@@ -180,7 +180,7 @@
   [page-name]
   (when-let [page (some-> page-name (db-model/get-page))]
     (when-let [^Object worker @db-browser/*worker]
-      (p/let [result (worker :general/get-block-and-children
+      (p/let [result (worker :thread-api/get-block-and-children
                              (state/get-current-repo)
                              (:block/uuid page)
                              {:children? true
@@ -192,7 +192,7 @@
   (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 (worker :general/get-block-refs graph eid)
+    (p/let [result (worker :thread-api/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"))))
@@ -202,7 +202,7 @@
   [graph eid]
   (assert (integer? eid))
   (when-let [worker @db-browser/*worker]
-    (worker :general/get-block-refs-count graph eid)))
+    (worker :thread-api/get-block-refs-count graph eid)))
 
 (defn <get-all-referenced-blocks-uuid
   "Get all uuids of blocks with any back link exists."

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

@@ -16,7 +16,7 @@
       (if async-requested?
         (let [db (db-conn/get-db graph)]
           (apply d/q (first inputs) db (rest inputs)))
-        (p/let [result (worker :general/q graph inputs)]
+        (p/let [result (worker :thread-api/q graph inputs)]
           (swap! *async-queries assoc [inputs opts] true)
           (when result
             (when (and transact-db? (seq result) (coll? result))
@@ -41,7 +41,7 @@
    (<pull graph '[*] id))
   ([graph selector id]
    (when-let [worker @state/*db-worker]
-     (p/let [result' (worker :general/pull graph selector id)]
+     (p/let [result' (worker :thread-api/pull graph selector id)]
        (when result'
          (when-let [conn (db-conn/get-db graph false)]
            (d/transact! conn [result']))

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

@@ -20,7 +20,7 @@
 (defn- stop
   []
   (let [worker @db-browser/*worker]
-    (worker :rtc/stop))
+    (worker :thread-api/rtc-stop))
   (reset! debug-state nil))
 
 (rum/defcs ^:large-vars/cleanup-todo rtc-debug-ui < rum/reactive
@@ -60,7 +60,7 @@
        {:size :sm
         :on-click (fn [_]
                     (let [worker @db-browser/*worker]
-                      (p/let [new-state (worker :rtc/get-debug-state)]
+                      (p/let [new-state (worker :thread-api/rtc-get-debug-state)]
                         (swap! debug-state (fn [old] (merge old new-state))))))}
        (shui/tabler-icon "refresh") "state")
 
@@ -70,7 +70,7 @@
         (fn [_]
           (let [token (state/get-auth-id-token)
                 worker @db-browser/*worker]
-            (p/let [graph-list (worker :rtc/get-graphs token)]
+            (p/let [graph-list (worker :thread-api/rtc-get-graphs token)]
               (swap! debug-state assoc
                      :remote-graphs
                      (map
@@ -119,7 +119,7 @@
          :on-click (fn []
                      (let [token (state/get-auth-id-token)
                            worker @db-browser/*worker]
-                       (worker :rtc/start (state/get-current-repo) token)))}
+                       (worker :thread-api/rtc-start (state/get-current-repo) token)))}
         (shui/tabler-icon "player-play") "start")
 
        [:div.my-2.flex
@@ -130,7 +130,7 @@
                               {:on-click
                                (fn []
                                  (let [worker @db-browser/*worker]
-                                   (worker :rtc/toggle-auto-push)))})]
+                                   (worker :thread-api/rtc-toggle-auto-push)))})]
         [:div.mr-2 (ui/button (str "Toggle remote profile("
                                    (if (:remote-profile? debug-state*)
                                      "ON" "OFF")
@@ -138,7 +138,7 @@
                               {:on-click
                                (fn []
                                  (let [worker @db-browser/*worker]
-                                   (worker :rtc/toggle-remote-profile)))})]
+                                   (worker :thread-api/rtc-toggle-remote-profile)))})]
         [:div (shui/button
                {:variant :outline
                 :class "text-red-rx-09 border-red-rx-08 hover:text-red-rx-10"
@@ -157,7 +157,7 @@
                                       user-email (when-not user-uuid (:grant-access-to-user debug-state*))]
                                   (when-let [graph-uuid (:graph-uuid debug-state*)]
                                     (let [worker @db-browser/*worker]
-                                      (worker :rtc/grant-graph-access
+                                      (worker :thread-api/rtc-grant-graph-access
                                               token graph-uuid
                                               (some-> user-uuid vector)
                                               (some-> user-email vector))))))})
@@ -183,7 +183,7 @@
                                   (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 (worker :rtc/request-download-graph
+                                            download-info-uuid (worker :thread-api/rtc-request-download-graph
                                                                        token graph-uuid graph-schema-version)
                                             {:keys [_download-info-uuid
                                                     download-info-s3-url
@@ -191,11 +191,11 @@
                                                     _download-info-t
                                                     _download-info-created-at]
                                              :as result}
-                                            (worker :rtc/wait-download-graph-info-ready
+                                            (worker :thread-api/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
+                                        (worker :thread-api/rtc-download-graph-from-s3
                                                 graph-uuid graph-name download-info-s3-url)))))))})
 
       [:b "➡"]
@@ -232,7 +232,7 @@
                                     token (state/get-auth-id-token)
                                     remote-graph-name (:upload-as-graph-name debug-state*)
                                     worker @db-browser/*worker]
-                                (worker :rtc/async-upload-graph repo token remote-graph-name)))})
+                                (worker :thread-api/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,7 +249,7 @@
                                 (let [token (state/get-auth-id-token)
                                       worker @db-browser/*worker]
                                   (prn ::delete-graph graph-uuid graph-schema-version)
-                                  (worker :rtc/delete-graph token graph-uuid graph-schema-version))))})
+                                  (worker :thread-api/rtc-delete-graph token graph-uuid graph-schema-version))))})
 
       (shui/select
        {:on-value-change (fn [[graph-uuid graph-schema-version]]
@@ -277,8 +277,8 @@
           {:size :sm
            :on-click (fn [_]
                        (let [worker @db-browser/*worker]
-                         (p/let [graph-keys (worker :rtc/get-graph-keys (state/get-current-repo))
-                                 devices (some->> (state/get-auth-id-token) (worker :device/list-devices))]
+                         (p/let [graph-keys (worker :thread-api/rtc-get-graph-keys (state/get-current-repo))
+                                 devices (some->> (state/get-auth-id-token) (worker :thread-api/list-devices))]
                            (swap! (get state ::keys-state) #(merge % graph-keys {:devices devices})))))}
           (shui/tabler-icon "refresh") "keys-state")]
         [:div.pb-4
@@ -293,7 +293,7 @@
                       (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)]
-                            (worker :device/remove-device token device-uuid)))))}
+                            (worker :thread-api/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,7 +308,7 @@
                         (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)]
-                              (worker :device/remove-device-public-key token device-uuid key-name))))))}
+                              (worker :thread-api/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)))
@@ -328,7 +328,7 @@
                       (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))]
-                            (worker :rtc/sync-current-graph-encrypted-aes-key
+                            (worker :thread-api/rtc-sync-current-graph-encrypted-aes-key
                                     token [(parse-uuid device-uuid)])))))}
          "Sync CurrentGraph EncryptedAesKey")
         [:input.form-input.my-2.py-1.w-32

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

@@ -91,7 +91,7 @@
 
 (defn ^:export validate-db []
   (when-let [worker @state/*db-worker]
-    (worker :general/validate-db (state/get-current-repo))))
+    (worker :thread-api/validate-db (state/get-current-repo))))
 
 (defn import-chosen-graph
   [repo]

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

@@ -14,7 +14,7 @@
   ;; 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
+      (p/let [result (worker :thread-api/export-edn
                              (state/get-current-repo)
                              {:export-type :block :block-id [:block/uuid block-uuid]})
               pull-data (with-out-str (pprint/pprint result))]
@@ -26,7 +26,7 @@
 (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
+      (p/let [result (worker :thread-api/export-edn
                              (state/get-current-repo)
                              {:export-type :view-nodes :node-ids block-uuids})
               pull-data (with-out-str (pprint/pprint result))]
@@ -37,7 +37,7 @@
 (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
+      (p/let [result (worker :thread-api/export-edn
                              (state/get-current-repo)
                              {:export-type :page :page-id page-id})
               pull-data (with-out-str (pprint/pprint result))]
@@ -48,7 +48,7 @@
 
 (defn ^:export export-graph-ontology-data []
   (when-let [worker @state/*db-worker]
-    (p/let [result (worker :general/export-edn
+    (p/let [result (worker :thread-api/export-edn
                            (state/get-current-repo)
                            {:export-type :graph-ontology})
             pull-data (with-out-str (pprint/pprint result))]
@@ -60,7 +60,7 @@
 
 (defn- export-graph-edn-data []
   (when-let [worker @state/*db-worker]
-    (p/let [result (worker :general/export-edn
+    (p/let [result (worker :thread-api/export-edn
                            (state/get-current-repo)
                            {:export-type :graph
                             :graph-options {:include-timestamps? true}})

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

@@ -21,7 +21,7 @@
      (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)]
-       (worker :rtc/async-upload-graph repo token repo-name)))))
+       (worker :thread-api/rtc-async-upload-graph repo token repo-name)))))
 
 (defn <rtc-delete-graph!
   [graph-uuid schema-version]
@@ -29,7 +29,7 @@
     (p/do!
      (js/Promise. user-handler/task--ensure-id&access-token)
      (let [token (state/get-auth-id-token)]
-       (worker :rtc/delete-graph token graph-uuid schema-version)))))
+       (worker :thread-api/rtc-delete-graph token graph-uuid schema-version)))))
 
 (defn <rtc-download-graph!
   [graph-name graph-uuid graph-schema-version timeout-ms]
@@ -38,33 +38,33 @@
     (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 (worker :thread-api/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}
-            (worker :rtc/wait-download-graph-info-ready
+            (worker :thread-api/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)
-         (worker :rtc/download-graph-from-s3 graph-uuid graph-name download-info-s3-url))
+         (worker :thread-api/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 [worker @state/*db-worker]
-    (worker :rtc/stop)))
+    (worker :thread-api/rtc-stop)))
 
 (defn <rtc-branch-graph!
   [repo]
   (when-let [worker @state/*db-worker]
     (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)
             token (state/get-auth-id-token)
-            start-ex (worker :rtc/async-branch-graph repo token)]
+            start-ex (worker :thread-api/rtc-async-branch-graph repo token)]
       (when-let [ex-data* (:ex-data start-ex)]
         (throw (ex-info (:ex-message start-ex) ex-data*))))))
 
@@ -103,7 +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 [start-ex (worker :rtc/start repo token)
+         (p/let [start-ex (worker :thread-api/rtc-start repo token)
                  ex-data* (:ex-data start-ex)
                  _ (case (:type ex-data*)
                      (:rtc.exception/not-rtc-graph
@@ -138,7 +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)
-            graphs (worker :rtc/get-graphs token)
+            graphs (worker :thread-api/rtc-get-graphs token)
             result (->> graphs
                         (remove (fn [graph] (= (:graph-status graph) "deleting")))
                         (mapv (fn [graph]
@@ -158,7 +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 graph-uuid)]
+              result (worker :thread-api/rtc-get-users-info token graph-uuid)]
         (state/set-state! :rtc/users-info {repo result})))))
 
 (defn <rtc-invite-email
@@ -167,7 +167,7 @@
     (let [token (state/get-auth-id-token)]
       (->
        (p/do!
-        (worker :rtc/grant-graph-access
+        (worker :thread-api/rtc-grant-graph-access
                 token (str graph-uuid) [] [email])
         (notification/show! "Invitation sent!" :success))
        (p/catch (fn [e]

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

@@ -37,7 +37,7 @@
             page-id (:block/uuid (:block/page (db/entity (:db/id (state/get-edit-block)))))
             repo (state/get-current-repo)]
         (when page-id
-          (worker :undo-redo/record-editor-info repo (str page-id) (state/get-editor-info)))))
+          (worker :thread-api/record-editor-info repo (str page-id) (state/get-editor-info)))))
 
     (state/set-state! :editor/op nil))
   state)

src/main/frontend/handler/events.cljs

@@ -206,7 +206,7 @@
   (reset! r/*key->atom {})
 
   (let [worker @db-browser/*worker]
-    (p/let [writes-finished? (when worker (worker :general/file-writes-finished? (state/get-current-repo)))
+    (p/let [writes-finished? (when worker (worker :thread-api/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
@@ -367,7 +367,7 @@
                  :pages-directory (config/get-pages-directory)}
         worker @state/*db-worker]
     (when worker
-      (worker :general/set-context context))))
+      (worker :thread-api/set-context 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,17 +190,17 @@
 (defn <get-all-pages
   [repo]
   (when-let [worker @db-browser/*worker]
-    (worker :export/get-all-pages repo)))
+    (worker :thread-api/export-get-all-pages repo)))
 
 (defn <get-debug-datoms
   [repo]
   (when-let [worker @db-browser/*worker]
-    (worker :export/get-debug-datoms repo)))
+    (worker :thread-api/export-get-debug-datoms repo)))
 
 (defn <get-all-page->content
   [repo]
   (when-let [worker @db-browser/*worker]
-    (worker :export/get-all-page->content repo)))
+    (worker :thread-api/export-get-all-page->content repo)))
 
 (defn <get-file-contents
   [repo suffix]

src/main/frontend/handler/history.cljs

@@ -59,7 +59,7 @@
               (editor/save-current-block!)
               (state/clear-editor-action!)
               (let [worker @state/*db-worker]
-                (reset! *last-request (worker :undo-redo/undo repo current-page-uuid-str))
+                (reset! *last-request (worker :thread-api/undo repo current-page-uuid-str))
                 (p/let [result @*last-request]
                   (restore-cursor-and-state! result)))))))))))
 (defonce undo! (debounce undo-aux! 20))
@@ -80,7 +80,7 @@
              (util/stop e)
              (state/clear-editor-action!)
              (let [worker @state/*db-worker]
-               (reset! *last-request (worker :undo-redo/redo repo current-page-uuid-str))
+               (reset! *last-request (worker :thread-api/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

@@ -14,14 +14,14 @@
   (let [{:keys [request-id page-id repo files]} data]
     (->
      (p/let [_ (file-handler/alter-files repo files {})]
-       (worker :general/page-file-saved request-id page-id))
+       (worker :thread-api/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)
-                (worker :general/page-file-saved request-id page-id))))))
+                (worker :thread-api/page-file-saved request-id page-id))))))
 
 (defmethod handle :notification [_ _worker data]
   (apply notification/show! data))

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

@@ -31,7 +31,7 @@
                                                 ~opts))
                (when (and worker# (seq r#))
                  (let [request-id# (frontend.state/get-worker-next-request-id)
-                       request# #(worker# :general/apply-outliner-ops
+                       request# #(worker# :thread-api/apply-outliner-ops
                                           (frontend.state/get-current-repo)
                                           r#
                                           (assoc ~opts

src/main/frontend/persist_db/browser.cljs

@@ -37,7 +37,7 @@
                                  (not= (:config prev) (:config current))
                                  (assoc :config (:config current)))]
                  (when (seq new-state)
-                   (worker :general/sync-app-state new-state))))))
+                   (worker :thread-api/sync-app-state new-state))))))
 
 (defn get-route-data
   [route-match]
@@ -58,7 +58,7 @@
                        old-state (f prev)
                        new-state (f current)]
                    (when (not= new-state old-state)
-                     (worker :general/sync-ui-state
+                     (worker :thread-api/sync-ui-state
                              (state/get-current-repo)
                              {:old-state old-state :new-state new-state})))))))
 
@@ -78,7 +78,7 @@
                  :whiteboards-directory (config/get-whiteboards-directory)
                  :pages-directory (config/get-pages-directory)}]
     (if worker
-      (worker :general/transact repo tx-data tx-meta context)
+      (worker :thread-api/transact repo tx-data tx-meta context)
       (notification/show! "Latest change was not saved! Please restart the application." :error))))
 
 (defn- with-write-transit-str
@@ -128,9 +128,9 @@
       (Comlink/expose (Main.) worker)
       (worker-handler/handle-message! worker wrapped-worker*)
       (reset! *worker wrapped-worker)
-      (-> (p/let [_ (wrapped-worker :general/init config/RTC-WS-URL)
+      (-> (p/let [_ (wrapped-worker :thread-api/init config/RTC-WS-URL)
                   _ (js/console.debug (str "debug: init worker spent: " (- (util/time-ms) t1) "ms"))
-                  _ (wrapped-worker :general/sync-app-state
+                  _ (wrapped-worker :thread-api/sync-app-state
                                     {:git/current-repo (state/get-current-repo)
                                      :config (:config @state/state)})
                   _ (sync-app-state! wrapped-worker)
@@ -174,34 +174,34 @@
   protocol/PersistentDB
   (<new [_this repo opts]
     (when-let [worker @*worker]
-      (worker :general/create-or-open-db repo opts)))
+      (worker :thread-api/create-or-open-db repo opts)))
 
   (<list-db [_this]
     (when-let [worker @*worker]
-      (-> (worker :general/list-db)
+      (-> (worker :thread-api/list-db)
           (p/catch sqlite-error-handler))))
 
   (<unsafe-delete [_this repo]
     (when-let [worker @*worker]
-      (worker :general/unsafe-unlink-db repo)))
+      (worker :thread-api/unsafe-unlink-db repo)))
 
   (<release-access-handles [_this repo]
     (when-let [worker @*worker]
-      (worker :general/release-access-handles repo)))
+      (worker :thread-api/release-access-handles repo)))
 
   (<fetch-initial-data [_this repo opts]
     (when-let [^js worker @*worker]
-      (-> (p/let [db-exists? (worker :general/db-exists repo)
+      (-> (p/let [db-exists? (worker :thread-api/db-exists repo)
                   disk-db-data (when-not db-exists? (ipc/ipc :db-get repo))
                   _ (when disk-db-data
-                      (worker :general/import-db repo disk-db-data))
-                  _ (worker :general/create-or-open-db repo opts)]
-            (worker :general/get-initial-data repo))
+                      (worker :thread-api/import-db repo disk-db-data))
+                  _ (worker :thread-api/create-or-open-db repo opts)]
+            (worker :thread-api/get-initial-data repo))
           (p/catch sqlite-error-handler))))
 
   (<export-db [_this repo opts]
     (when-let [worker @*worker]
-      (-> (p/let [data (worker :general/export-db repo)]
+      (-> (p/let [data (worker :thread-api/export-db repo)]
             (when data
               (if (:return-data? opts)
                 data
@@ -213,7 +213,7 @@
 
   (<import-db [_this repo data]
     (when-let [worker @*worker]
-      (-> (worker :general/import-db repo data)
+      (-> (worker :thread-api/import-db repo data)
           (p/catch (fn [error]
                      (prn :debug :import-db-error repo)
                      (js/console.error error)

src/main/frontend/publishing.cljs

@@ -57,7 +57,7 @@
       (p/let [_ (repo-handler/restore-and-setup-repo! repo)
               _ (let [db-transit-str (unescape-html data)]
                   (when-let [worker @state/*db-worker]
-                    (worker :general/reset-db repo db-transit-str)))
+                    (worker :thread-api/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

@@ -126,7 +126,7 @@
                       (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) eids))]
+                     (@state/*db-worker :thread-api/get-page-unlinked-refs repo (:db/id entity) eids))]
       (when result (d/transact! (db/get-db repo false) result))
       (some->> result
                db-model/sort-by-order-recursive

src/main/frontend/search/browser.cljs

@@ -13,18 +13,18 @@
   protocol/Engine
   (query [_this q option]
     (if-let [worker @*worker]
-      (worker :search/search-blocks (state/get-current-repo) q option)
+      (worker :thread-api/search-blocks (state/get-current-repo) q option)
       (p/resolved nil)))
   (rebuild-pages-indice! [_this]
     (if-let [worker @*worker]
-      (worker :search/build-pages-indice repo)
+      (worker :thread-api/search-build-pages-indice repo)
       (p/resolved nil)))
   (rebuild-blocks-indice! [this]
     (if-let [worker @*worker]
       (p/let [repo (state/get-current-repo)
               file-based? (config/local-file-based-graph? repo)
               _ (protocol/truncate-blocks! this)
-              result (worker :search/build-blocks-indice repo)
+              result (worker :thread-api/search-build-blocks-indice repo)
               blocks (if file-based?
                        (->> result
                             ;; remove built-in properties from content
@@ -34,20 +34,20 @@
                                         (property-util/remove-built-in-properties (get % :format :markdown) content)))))
                        result)
               _ (when (seq blocks)
-                  (worker :search/upsert-blocks repo blocks))])
+                  (worker :thread-api/search-upsert-blocks repo blocks))])
       (p/resolved nil)))
   (transact-blocks! [_this {:keys [blocks-to-remove-set
                                    blocks-to-add]}]
     (if-let [worker @*worker]
       (let [repo (state/get-current-repo)]
         (p/let [_ (when (seq blocks-to-remove-set)
-                    (worker :search/delete-blocks repo blocks-to-remove-set))]
+                    (worker :thread-api/search-delete-blocks repo blocks-to-remove-set))]
           (when (seq blocks-to-add)
-            (worker :search/upsert-blocks repo blocks-to-add))))
+            (worker :thread-api/search-upsert-blocks repo blocks-to-add))))
       (p/resolved nil)))
   (truncate-blocks! [_this]
     (if-let [worker @*worker]
-      (worker :search/truncate-tables (state/get-current-repo))
+      (worker :thread-api/search-truncate-tables (state/get-current-repo))
       (p/resolved nil)))
   (remove-db! [_this]
     ;; Already removed in OPFS

src/main/frontend/worker/crypt.cljs

@@ -124,6 +124,6 @@
     (let [aes-key-datom (first (d/datoms @conn :avet :aes-key-jwk))]
       {:aes-key-jwk (:v aes-key-datom)})))
 
-(def-thread-api :rtc/get-graph-keys
+(def-thread-api :thread-api/rtc-get-graph-keys
   [repo]
   (get-graph-keys-jwk repo))

src/main/frontend/worker/db_listener.cljs

@@ -32,9 +32,9 @@
         (p/do!
          (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 blocks-to-remove-set))
+             ((@thread-api/*thread-apis :thread-api/search-delete-blocks) repo blocks-to-remove-set))
            (when (seq blocks-to-add)
-             ((@thread-api/*thread-apis :search/upsert-blocks) repo blocks-to-add))))))
+             ((@thread-api/*thread-apis :thread-api/search-upsert-blocks) repo blocks-to-add))))))
     tx-report'))
 
 (comment

src/main/frontend/worker/db_worker.cljs

@@ -418,7 +418,7 @@
                       {:name graph-name
                        :metadata (edn/read-string metadata)})) db-dirs)))))
 
-(def-thread-api :general/list-db
+(def-thread-api :thread-api/list-db
   []
   (<list-all-dbs))
 
@@ -441,17 +441,17 @@
   [repo]
   (worker-state/get-sqlite-conn repo :search))
 
-(def-thread-api :general/get-version
+(def-thread-api :thread-api/get-version
   []
   (when-let [sqlite @*sqlite]
     (.-version sqlite)))
 
-(def-thread-api :general/init
+(def-thread-api :thread-api/init
   [rtc-ws-url]
   (reset! worker-state/*rtc-ws-url rtc-ws-url)
   (init-sqlite-module!))
 
-(def-thread-api :general/create-or-open-db
+(def-thread-api :thread-api/create-or-open-db
   [repo opts]
   (let [{:keys [close-other-db?] :or {close-other-db? true} :as opts} opts]
     (p/do!
@@ -460,12 +460,12 @@
      (create-or-open-db! repo (dissoc opts :close-other-db?))
      nil)))
 
-(def-thread-api :general/q
+(def-thread-api :thread-api/q
   [repo inputs]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (apply d/q (first inputs) @conn (rest inputs))))
 
-(def-thread-api :general/pull
+(def-thread-api :thread-api/pull
   [repo selector id]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (let [eid (if (and (vector? id) (= :block/name (first id)))
@@ -475,40 +475,40 @@
                (d/pull @conn selector)
                (sqlite-common-db/with-parent @conn)))))
 
-(def-thread-api :general/get-block-and-children
+(def-thread-api :thread-api/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)]
       (sqlite-common-db/get-block-and-children @conn id opts))))
 
-(def-thread-api :general/get-block-refs
+(def-thread-api :thread-api/get-block-refs
   [repo id]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (ldb/get-block-refs @conn id)))
 
-(def-thread-api :general/get-block-refs-count
+(def-thread-api :thread-api/get-block-refs-count
   [repo id]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (ldb/get-block-refs-count @conn id)))
 
-(def-thread-api :general/get-block-parents
+(def-thread-api :thread-api/get-block-parents
   [repo id depth]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (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
+(def-thread-api :thread-api/get-page-unlinked-refs
   [repo page-id search-result-eids]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (ldb/get-page-unlinked-refs @conn page-id search-result-eids)))
 
-(def-thread-api :general/set-context
+(def-thread-api :thread-api/set-context
   [context]
   (when context (worker-state/update-context! context))
   nil)
 
-(def-thread-api :general/transact
+(def-thread-api :thread-api/transact
   [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)]
@@ -542,90 +542,90 @@
         (js/console.error e)
         (prn :debug :tx-data @conn tx-data)))))
 
-(def-thread-api :general/get-initial-data
+(def-thread-api :thread-api/get-initial-data
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (sqlite-common-db/get-initial-data @conn)))
 
-(def-thread-api :general/get-page-refs-count
+(def-thread-api :thread-api/get-page-refs-count
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (sqlite-common-db/get-page->refs-count @conn)))
 
-(def-thread-api :general/close-db
+(def-thread-api :thread-api/close-db
   [repo]
   (close-db! repo)
   nil)
 
-(def-thread-api :general/reset-db
+(def-thread-api :thread-api/reset-db
   [repo db-transit]
   (reset-db! repo db-transit)
   nil)
 
-(def-thread-api :general/unsafe-unlink-db
+(def-thread-api :thread-api/unsafe-unlink-db
   [repo]
   (p/let [pool (<get-opfs-pool repo)
           _ (close-db! repo)
           _result (remove-vfs! pool)]
     nil))
 
-(def-thread-api :general/release-access-handles
+(def-thread-api :thread-api/release-access-handles
   [repo]
   (when-let [^js pool (worker-state/get-opfs-pool repo)]
     (.releaseAccessHandles pool)
     nil))
 
-(def-thread-api :general/db-exists
+(def-thread-api :thread-api/db-exists
   [repo]
   (<db-exists? repo))
 
-(def-thread-api :general/export-db
+(def-thread-api :thread-api/export-db
   [repo]
   (when-let [^js db (worker-state/get-sqlite-conn repo :db)]
     (.exec db "PRAGMA wal_checkpoint(2)"))
   (<export-db-file repo))
 
-(def-thread-api :general/import-db
+(def-thread-api :thread-api/import-db
   [repo data]
   (when-not (string/blank? repo)
     (p/let [pool (<get-opfs-pool repo)]
       (<import-db pool data)
       nil)))
 
-(def-thread-api :search/search-blocks
+(def-thread-api :thread-api/search-blocks
   [repo q option]
   (p/let [search-db (get-search-db repo)
           conn (worker-state/get-datascript-conn repo)]
     (search/search-blocks repo conn search-db q option)))
 
-(def-thread-api :search/upsert-blocks
+(def-thread-api :thread-api/search-upsert-blocks
   [repo blocks]
   (p/let [db (get-search-db repo)]
     (search/upsert-blocks! db (bean/->js blocks))
     nil))
 
-(def-thread-api :search/delete-blocks
+(def-thread-api :thread-api/search-delete-blocks
   [repo ids]
   (p/let [db (get-search-db repo)]
     (search/delete-blocks! db ids)
     nil))
 
-(def-thread-api :search/truncate-tables
+(def-thread-api :thread-api/search-truncate-tables
   [repo]
   (p/let [db (get-search-db repo)]
     (search/truncate-table! db)
     nil))
 
-(def-thread-api :search/build-blocks-indice
+(def-thread-api :thread-api/search-build-blocks-indice
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (search/build-blocks-indice repo @conn)))
 
-(def-thread-api :search/build-pages-indice
+(def-thread-api :thread-api/search-build-pages-indice
   [_repo]
   nil)
 
-(def-thread-api :general/apply-outliner-ops
+(def-thread-api :thread-api/apply-outliner-ops
   [repo ops opts]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (try
@@ -640,7 +640,7 @@
             (worker-util/post-message type [(:message payload) (:type payload)])
             (throw e)))))))
 
-(def-thread-api :general/file-writes-finished?
+(def-thread-api :thread-api/file-writes-finished?
   [repo]
   (let [conn (worker-state/get-datascript-conn repo)
         writes @file/*writes]
@@ -656,60 +656,60 @@
         (prn "Unfinished file writes:" @file/*writes)
         false))))
 
-(def-thread-api :general/page-file-saved
+(def-thread-api :thread-api/page-file-saved
   [request-id _page-id]
   (file/dissoc-request! request-id)
   nil)
 
-(def-thread-api :general/sync-app-state
+(def-thread-api :thread-api/sync-app-state
   [new-state]
   (worker-state/set-new-state! new-state)
   nil)
 
-(def-thread-api :general/sync-ui-state
+(def-thread-api :thread-api/sync-ui-state
   [repo state]
   (undo-redo/record-ui-state! repo (ldb/write-transit-str state))
   nil)
 
-(def-thread-api :export/get-debug-datoms
+(def-thread-api :thread-api/export-get-debug-datoms
   [repo]
   (when-let [db (worker-state/get-sqlite-conn repo)]
     (let [conn (worker-state/get-datascript-conn repo)]
       (worker-export/get-debug-datoms conn db))))
 
-(def-thread-api :export/get-all-pages
+(def-thread-api :thread-api/export-get-all-pages
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (worker-export/get-all-pages repo @conn)))
 
-(def-thread-api :export/get-all-page->content
+(def-thread-api :thread-api/export-get-all-page->content
   [repo]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (worker-export/get-all-page->content repo @conn)))
 
-(def-thread-api :undo-redo/undo
+(def-thread-api :thread-api/undo
   [repo _page-block-uuid-str]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (undo-redo/undo repo conn)))
 
-(def-thread-api :undo-redo/redo
+(def-thread-api :thread-api/redo
   [repo _page-block-uuid-str]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (undo-redo/redo repo conn)))
 
-(def-thread-api :undo-redo/record-editor-info
+(def-thread-api :thread-api/record-editor-info
   [repo _page-block-uuid-str editor-info]
   (undo-redo/record-editor-info! repo editor-info)
   nil)
 
-(def-thread-api :general/validate-db
+(def-thread-api :thread-api/validate-db
   [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)))
 
-(def-thread-api :general/export-edn
+(def-thread-api :thread-api/export-edn
   [repo options]
   (let [conn (worker-state/get-datascript-conn repo)]
     (try

src/main/frontend/worker/device.cljs

@@ -207,18 +207,18 @@
                 (m/? (new-task--sync-encrypted-aes-key*
                       get-ws-create-task device-uuid->encrypted-aes-key graph-uuid))))))))))
 
-(def-thread-api :rtc/sync-current-graph-encrypted-aes-key
+(def-thread-api :thread-api/rtc-sync-current-graph-encrypted-aes-key
   [token device-uuids]
   (new-task--sync-current-graph-encrypted-aes-key token device-uuids))
 
-(def-thread-api :device/list-devices
+(def-thread-api :thread-api/list-devices
   [token]
   (new-task--list-devices token))
 
-(def-thread-api :device/remove-device-public-key
+(def-thread-api :thread-api/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
+(def-thread-api :thread-api/remove-device
   [token device-uuid]
   (new-task--remove-device token device-uuid))

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

@@ -531,69 +531,69 @@
 
 (def new-task--download-graph-from-s3 r.upload-download/new-task--download-graph-from-s3)
 
-(def-thread-api :rtc/start
+(def-thread-api :thread-api/rtc-start
   [repo token]
   (new-task--rtc-start repo token))
 
-(def-thread-api :rtc/stop
+(def-thread-api :thread-api/rtc-stop
   []
   (rtc-stop))
 
-(def-thread-api :rtc/toggle-auto-push
+(def-thread-api :thread-api/rtc-toggle-auto-push
   []
   (rtc-toggle-auto-push))
 
-(def-thread-api :rtc/toggle-remote-profile
+(def-thread-api :thread-api/rtc-toggle-remote-profile
   []
   (rtc-toggle-remote-profile))
 
-(def-thread-api :rtc/grant-graph-access
+(def-thread-api :thread-api/rtc-grant-graph-access
   [token graph-uuid target-user-uuids 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
+(def-thread-api :thread-api/rtc-get-graphs
   [token]
   (new-task--get-graphs token))
 
-(def-thread-api :rtc/delete-graph
+(def-thread-api :thread-api/rtc-delete-graph
   [token graph-uuid schema-version]
   (new-task--delete-graph token graph-uuid schema-version))
 
-(def-thread-api :rtc/get-users-info
+(def-thread-api :thread-api/rtc-get-users-info
   [token graph-uuid]
   (new-task--get-users-info token graph-uuid))
 
-(def-thread-api :rtc/get-block-content-versions
+(def-thread-api :thread-api/rtc-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
+(def-thread-api :thread-api/rtc-get-debug-state
   []
   (new-task--get-debug-state))
 
-(def-thread-api :rtc/async-upload-graph
+(def-thread-api :thread-api/rtc-async-upload-graph
   [repo token remote-graph-name]
   (new-task--upload-graph token repo remote-graph-name))
 
-(def-thread-api :rtc/async-branch-graph
+(def-thread-api :thread-api/rtc-async-branch-graph
   [repo token]
   (new-task--branch-graph token repo))
 
-(def-thread-api :rtc/request-download-graph
+(def-thread-api :thread-api/rtc-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
+(def-thread-api :thread-api/rtc-wait-download-graph-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
+(def-thread-api :thread-api/rtc-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
+(def-thread-api :thread-api/rtc-download-info-list
   [token graph-uuid schema-version]
   (new-task--download-info-list token graph-uuid schema-version))
 

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

@@ -357,9 +357,9 @@
         (create-graph-for-rtc-test repo init-tx-data tx-data)
         (c.m/<?
          (p/do!
-          ((@thread-api/*thread-apis :general/create-or-open-db) repo {:close-other-db? false})
-          ((@thread-api/*thread-apis :general/export-db) repo)
-          ((@thread-api/*thread-apis :general/transact)
+          ((@thread-api/*thread-apis :thread-api/create-or-open-db) repo {:close-other-db? false})
+          ((@thread-api/*thread-apis :thread-api/export-db) repo)
+          ((@thread-api/*thread-apis :thread-api/transact)
            repo init-tx-data
            {:rtc-download-graph? true
             :gen-undo-ops? false
@@ -367,7 +367,7 @@
             :frontend.worker.pipeline/skip-validate-db? true
             :persist-op? false}
            (worker-state/get-context))
-          ((@thread-api/*thread-apis :general/transact)
+          ((@thread-api/*thread-apis :thread-api/transact)
            repo tx-data {:rtc-download-graph? true
                          :gen-undo-ops? false
                          :persist-op? false} (worker-state/get-context))