fix: nbb not working in most deps

core.async isn't nbb compatible yet. Moved async transact to its own
frontend ns

deps/db/src/logseq/db.cljs

@@ -9,10 +9,7 @@
             [logseq.db.frontend.content :as db-content]
             [clojure.set :as set]
             [logseq.db.frontend.rules :as rules]
-            [logseq.db.frontend.entity-plus]
-            [promesa.core :as p]
-            [clojure.core.async :as async]
-            [clojure.core.async.interop :refer [p->c]]))
+            [logseq.db.frontend.entity-plus]))
 
 ;; Use it as an input argument for datalog queries
 (def block-attrs
@@ -51,36 +48,6 @@
   [f]
   (when f (reset! *transact-fn f)))
 
-(defonce *request-id (atom 0))
-(defonce requests (async/chan 1000))
-(defonce *unfinished-request-ids (atom #{}))
-
-(defn request-finished?
-  "Whether any DB transaction request has been finished"
-  []
-  (empty? @*unfinished-request-ids))
-
-(async/go-loop []
-  (when-let [{:keys [id request response]} (async/<! requests)]
-    (let [result (async/<! (p->c (request)))]
-      (p/resolve! response result)
-      (swap! *unfinished-request-ids disj id))
-    (recur)))
-
-(defn get-next-request-id
-  []
-  (swap! *request-id inc))
-
-(defn add-request!
-  [request-id request-f]
-  (let [resp (p/deferred)
-        new-request {:id request-id
-                     :request request-f
-                     :response resp}]
-    (swap! *unfinished-request-ids conj request-id)
-    (async/go (async/>! requests new-request))
-    resp))
-
 (defn transact!
   "`repo-or-conn`: repo for UI thread and conn for worker/node"
   ([repo-or-conn tx-data]
@@ -95,15 +62,8 @@
        ;; (prn :debug :transact :sync? (= d/transact! (or @*transact-fn d/transact!)))
        ;; (cljs.pprint/pprint tx-data)
 
-       (let [f (or @*transact-fn d/transact!)
-             sync? (= f d/transact!)
-             request-id (when-not sync? (get-next-request-id))
-             tx-meta' (cond-> tx-meta
-                        (not sync?)
-                        (assoc :request-id request-id))]
-         (if sync?
-           (f repo-or-conn tx-data tx-meta')
-           (add-request! request-id #(f repo-or-conn tx-data tx-meta'))))))))
+       (let [f (or @*transact-fn d/transact!)]
+         (f repo-or-conn tx-data tx-meta))))))
 
 (defn build-default-pages-tx
   []

src/main/frontend/db.cljs

@@ -5,6 +5,7 @@
             [frontend.db.query-custom]
             [frontend.db.query-react]
             [frontend.db.react :as react]
+            [frontend.db.transact :as db-transact]
             [frontend.db.utils]
             [frontend.namespaces :refer [import-vars]]
             [logseq.db.frontend.default :as default-db]
@@ -66,4 +67,4 @@
    (conn/start! repo option)))
 
 (def new-block-id ldb/new-block-id)
-(def request-finished? ldb/request-finished?)
+(def request-finished? db-transact/request-finished?)

src/main/frontend/db/transact.cljs

@@ -0,0 +1,45 @@
+(ns frontend.db.transact
+  "Provides async transact for use with ldb/transact!"
+  (:require [clojure.core.async :as async]
+            [clojure.core.async.interop :refer [p->c]]
+            [promesa.core :as p]))
+
+(defonce *request-id (atom 0))
+(defonce requests (async/chan 1000))
+(defonce *unfinished-request-ids (atom #{}))
+
+(defn request-finished?
+  "Whether any DB transaction request has been finished"
+  []
+  (empty? @*unfinished-request-ids))
+
+(defn get-next-request-id
+  []
+  (swap! *request-id inc))
+
+(defn add-request!
+  [request-id request-f]
+  (let [resp (p/deferred)
+        new-request {:id request-id
+                     :request request-f
+                     :response resp}]
+    (swap! *unfinished-request-ids conj request-id)
+    (async/go (async/>! requests new-request))
+    resp))
+
+(defn listen-for-requests []
+  (async/go-loop []
+    (when-let [{:keys [id request response]} (async/<! requests)]
+      (let [result (async/<! (p->c (request)))]
+        (p/resolve! response result)
+        (swap! *unfinished-request-ids disj id))
+      (recur))))
+
+(defn transact [worker-transact repo tx-data tx-meta]
+  (let [request-id (get-next-request-id)
+        tx-meta' (assoc tx-meta
+                        :request-id request-id
+                        ;; not from remote(rtc)
+                        :local-tx? true)]
+    (add-request! request-id (fn async-request []
+                                   (worker-transact repo tx-data tx-meta')))))

src/main/frontend/handler/events.cljs

@@ -30,6 +30,7 @@
             [frontend.db.conn :as conn]
             [frontend.db.model :as db-model]
             [frontend.db.persist :as db-persist]
+            [frontend.db.transact :as db-transact]
             [frontend.extensions.srs :as srs]
             [frontend.fs :as fs]
             [frontend.fs.capacitor-fs :as capacitor-fs]
@@ -80,8 +81,7 @@
             [frontend.db.rtc.debug-ui :as rtc-debug-ui]
             [frontend.modules.outliner.pipeline :as pipeline]
             [electron.ipc :as ipc]
-            [frontend.date :as date]
-            [logseq.db :as ldb]))
+            [frontend.date :as date]))
 
 ;; TODO: should we move all events here?
 
@@ -195,14 +195,14 @@
 
   (let [^js sqlite @db-browser/*worker]
     (p/let [writes-finished? (when sqlite (.file-writes-finished? sqlite (state/get-current-repo)))
-            request-finished? (ldb/request-finished?)]
+            request-finished? (db-transact/request-finished?)]
       (if (not writes-finished?) ; TODO: test (:sync-graph/init? @state/state)
         (do
           (log/info :graph/switch (cond->
                                     {:request-finished? request-finished?
                                      :file-writes-finished? writes-finished?}
                                     (false? request-finished?)
-                                    (assoc :unfinished-requests? @ldb/*unfinished-request-ids)))
+                                    (assoc :unfinished-requests? @db-transact/*unfinished-request-ids)))
           (notification/show!
             "Please wait seconds until all changes are saved for the current graph."
             :warning))
@@ -386,7 +386,7 @@
   (when-let [repo (state/get-current-repo)]
     (let [^js sqlite @db-browser/*worker]
       (p/let [writes-finished? (when sqlite (.file-writes-finished? sqlite (state/get-current-repo)))
-              request-finished? (ldb/request-finished?)]
+              request-finished? (db-transact/request-finished?)]
         (prn :debug :writes-finished? writes-finished?
           :request-finished? request-finished?)
         (when (and request-finished? writes-finished? disk-content db-content

src/main/frontend/handler/history.cljs

@@ -7,7 +7,7 @@
             [frontend.handler.route :as route-handler]
             [goog.dom :as gdom]
             [promesa.core :as p]
-            [logseq.db :as ldb]))
+            [frontend.db.transact :as db-transact]))
 
 (defn restore-cursor!
   [{:keys [last-edit-block container pos end-pos]} undo?]
@@ -41,7 +41,7 @@
 
 (defn undo!
   [e]
-  (when (ldb/request-finished?)
+  (when (db-transact/request-finished?)
     (util/stop e)
     (p/do!
      (state/set-state! [:editor/last-replace-ref-content-tx (state/get-current-repo)] nil)
@@ -53,7 +53,7 @@
 
 (defn redo!
   [e]
-  (when (ldb/request-finished?)
+  (when (db-transact/request-finished?)
     (util/stop e)
     (state/clear-editor-action!)
     (let [cursor-state (undo-redo/redo)]

src/main/frontend/persist_db/browser.cljs

@@ -13,6 +13,7 @@
             [electron.ipc :as ipc]
             [frontend.handler.worker :as worker-handler]
             [logseq.db :as ldb]
+            [frontend.db.transact :as db-transact]
             [frontend.date :as date]))
 
 (defonce *worker state/*db-worker)
@@ -80,10 +81,11 @@
             (ldb/register-transact-fn!
              (fn worker-transact!
                [repo tx-data tx-meta]
-               (let [repo' (if (string? repo) repo (state/get-current-repo))]
-                 (transact! wrapped-worker repo' tx-data
-                 ;; not from remote(rtc)
-                            (assoc tx-meta :local-tx? true))))))
+               (db-transact/transact (partial transact! wrapped-worker)
+                                     (if (string? repo) repo (state/get-current-repo))
+                                     tx-data
+                                     tx-meta)))
+            (db-transact/listen-for-requests))
           (p/catch (fn [error]
                      (prn :debug "Can't init SQLite wasm")
                      (js/console.error error)

src/main/frontend/state.cljs

@@ -15,7 +15,7 @@
             [goog.dom :as gdom]
             [goog.object :as gobj]
             [logseq.common.config :as common-config]
-            [logseq.db :as ldb]
+            [frontend.db.transact :as db-transact]
             [medley.core :as medley]
             [promesa.core :as p]
             [rum.core :as rum]
@@ -2375,5 +2375,5 @@ Similar to re-frame subscriptions"
   []
   (update-state! :favorites/updated? inc))
 
-(def get-worker-next-request-id ldb/get-next-request-id)
-(def add-worker-request! ldb/add-request!)
+(def get-worker-next-request-id db-transact/get-next-request-id)
+(def add-worker-request! db-transact/add-request!)