remove ns frontend.db.transact

src/main/frontend/common/async_util.cljc

@@ -6,14 +6,16 @@
                      [logseq.common.util :as common-util]
                      [promesa.core :as p])))
 
-#?(:cljs
-   (defn throw-err
-     [v]
-     (if (instance? ExceptionInfo v) (throw v) v)))
+(comment
+  #?(:cljs
+     (defn throw-err
+       [v]
+       (if (instance? ExceptionInfo v) (throw v) v))))
 
-(defmacro <?
-  [port]
-  `(throw-err (cljs.core.async/<! ~port)))
+(comment
+  (defmacro <?
+    [port]
+    `(throw-err (cljs.core.async/<! ~port))))
 
 #?(:cljs
    (defn c->p

src/main/frontend/common/thread_api.cljc

@@ -2,8 +2,7 @@
   "Macro for defining thread apis, which is invokeable by other threads"
   #?(:cljs (:require-macros [frontend.common.thread-api]))
   #?(:cljs (:require [logseq.db :as ldb]
-                     [promesa.core :as p]
-                     [lambdaisland.glogi :as log])))
+                     [promesa.core :as p])))
 
 #?(:cljs
    (def *thread-apis (volatile! {})))
@@ -28,8 +27,6 @@
      "Return a promise whose value is transit-str."
      [qualified-kw-str direct-pass? args-transit-str-or-args-array]
      (let [qkw (keyword qualified-kw-str)]
-       (log/info ::remote-function qualified-kw-str
-                 :thread-api-exists? (fn? (@*thread-apis qkw)))
        (vswap! *profile update qkw inc)
        (if-let [f (@*thread-apis qkw)]
          (let [result (if (= qkw :thread-api/set-infer-worker-proxy)

src/main/frontend/db/transact.cljs

@@ -1,76 +0,0 @@
-(ns frontend.db.transact
-  "Provides async transact for use with ldb/transact!"
-  (:require [clojure.core.async :as async]
-            [clojure.core.async.impl.protocols :as async-protocols]
-            [clojure.core.async.interop :refer [p->c]]
-            [frontend.common.async-util :include-macros true :refer [<?]]
-            [frontend.state :as state]
-            [lambdaisland.glogi :as log]
-            [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
-      (let [result (async/>! requests new-request)]
-        (when (false? result)
-          (log/error ::failed-to-add-transact-request
-                     {:request-id request-id
-                      :requests-chan-closed? (async-protocols/closed? requests)}))))
-    resp))
-
-(defn remove-request!
-  [request-id]
-  (swap! *unfinished-request-ids disj request-id))
-
-(defn- capture-error
-  [error]
-  (state/pub-event! [:capture-error
-                     {:error error
-                      :payload {:type :worker-request-failed}}]))
-
-(defn listen-for-requests []
-  (log/info ::transact-listen-to-requests {})
-  (async/go-loop []
-    (when-let [{:keys [id request response]} (async/<! requests)]
-      (try
-        (let [result (<? (p->c (request)))]
-          (if (:ex-data result)
-            (do
-              (log/error :worker-request-failed result)
-              (p/reject! response result)
-              (capture-error result))
-            (p/resolve! response result))
-          (remove-request! id))
-        (catch :default e
-          (log/error :worker-request-failed e)
-          (p/reject! response e)
-          (capture-error e)
-          (remove-request! 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/editor.cljs

@@ -327,7 +327,6 @@
 (defn outliner-insert-block!
   [config current-block new-block {:keys [sibling? keep-uuid? ordered-list?
                                           replace-empty-target?]}]
-  (log/info ::outliner-insert-block new-block)
   (let [ref-query-top-block? (and (or (:ref? config)
                                       (:custom-query? config))
                                   (not (:ref-query-child? config)))
@@ -506,7 +505,6 @@
   ([state]
    (insert-new-block! state nil))
   ([_state block-value]
-   (log/info ::insert-new-block {})
    (->
     (when (not config/publishing?)
       (when-let [state (get-state)]
@@ -2466,7 +2464,6 @@
 
 (defn- keydown-new-block
   [state]
-  (log/info ::keydown {})
   (when-not (auto-complete?)
     (let [{:keys [block config]} (get-state)]
       (when block

src/main/frontend/handler/events.cljs

@@ -16,7 +16,6 @@
             [frontend.db.async :as db-async]
             [frontend.db.model :as db-model]
             [frontend.db.react :as react]
-            [frontend.db.transact :as db-transact]
             [frontend.extensions.fsrs :as fsrs]
             [frontend.fs :as fs]
             [frontend.fs.sync :as sync]
@@ -119,15 +118,10 @@
   (state/set-state! :db/async-queries {})
   (st/refresh!)
 
-  (p/let [writes-finished? (state/<invoke-db-worker :thread-api/file-writes-finished? (state/get-current-repo))
-          request-finished? (db-transact/request-finished?)]
+  (p/let [writes-finished? (state/<invoke-db-worker :thread-api/file-writes-finished? (state/get-current-repo))]
     (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? @db-transact/*unfinished-request-ids)))
+        (log/info :graph/switch {:file-writes-finished? writes-finished?})
         (notification/show!
          "Please wait seconds until all changes are saved for the current graph."
          :warning))

src/main/frontend/handler/history.cljs

@@ -1,6 +1,5 @@
 (ns ^:no-doc frontend.handler.history
   (:require [frontend.db :as db]
-            [frontend.db.transact :as db-transact]
             [frontend.handler.editor :as editor]
             [frontend.handler.route :as route-handler]
             [frontend.persist-db.browser :as db-browser]
@@ -48,15 +47,14 @@
       (p/do!
        @*last-request
        (when-let [repo (state/get-current-repo)]
-         (when (db-transact/request-finished?)
-           (util/stop e)
-           (p/do!
-            (state/set-state! [:editor/last-replace-ref-content-tx repo] nil)
-            (editor/save-current-block!)
-            (state/clear-editor-action!)
-            (reset! *last-request (undo-redo/undo repo))
-            (p/let [result @*last-request]
-              (restore-cursor-and-state! result)))))))))
+         (util/stop e)
+         (p/do!
+          (state/set-state! [:editor/last-replace-ref-content-tx repo] nil)
+          (editor/save-current-block!)
+          (state/clear-editor-action!)
+          (reset! *last-request (undo-redo/undo repo))
+          (p/let [result @*last-request]
+            (restore-cursor-and-state! result))))))))
 (defonce undo! (debounce undo-aux! 20))
 
 (let [*last-request (atom nil)]
@@ -67,10 +65,9 @@
       (p/do!
        @*last-request
        (when-let [repo (state/get-current-repo)]
-         (when (db-transact/request-finished?)
-           (util/stop e)
-           (state/clear-editor-action!)
-           (reset! *last-request (undo-redo/redo repo))
-           (p/let [result @*last-request]
-             (restore-cursor-and-state! result))))))))
+         (util/stop e)
+         (state/clear-editor-action!)
+         (reset! *last-request (undo-redo/redo repo))
+         (p/let [result @*last-request]
+           (restore-cursor-and-state! result)))))))
 (defonce redo! (debounce redo-aux! 20))

src/main/frontend/handler/worker.cljs

@@ -6,7 +6,6 @@
             [frontend.handler.notification :as notification]
             [frontend.state :as state]
             [frontend.undo-redo :as undo-redo]
-            [frontend.util :as util]
             [lambdaisland.glogi :as log]
             [logseq.db :as ldb]
             [promesa.core :as p]))

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

@@ -25,9 +25,8 @@
           (state/set-edit-content! new-title))))))
 
 (defn invoke-hooks
-  [{:keys [_request-id repo tx-meta tx-data deleted-block-uuids deleted-assets affected-keys blocks]}]
+  [{:keys [repo tx-meta tx-data deleted-block-uuids deleted-assets affected-keys blocks]}]
   ;; (prn :debug
-  ;;      :request-id request-id
   ;;      :tx-meta tx-meta
   ;;      :tx-data tx-data)
   (let [{:keys [from-disk? new-graph? initial-pages? end?]} tx-meta

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

@@ -1,7 +1,6 @@
 (ns frontend.modules.outliner.ui
   #?(:cljs (:require-macros [frontend.modules.outliner.ui]))
   #?(:cljs (:require [frontend.state]
-                     [frontend.db.transact]
                      [frontend.db.conn]
                      [logseq.outliner.op]
                      [frontend.modules.outliner.op]
@@ -30,13 +29,9 @@
                                               (frontend.state/get-date-formatter)
                                               ~opts))
              (when (seq r#)
-               (let [request-id# (frontend.db.transact/get-next-request-id)
-                     request# #(frontend.state/<invoke-db-worker
-                                :thread-api/apply-outliner-ops
-                                (frontend.state/get-current-repo)
-                                r#
-                                (assoc ~opts
-                                       :request-id request-id#
-                                       :client-id (:client-id @frontend.state/state)))
-                     response# (frontend.db.transact/add-request! request-id# request#)]
-                 response#))))))))
+               (frontend.state/<invoke-db-worker
+                :thread-api/apply-outliner-ops
+                (frontend.state/get-current-repo)
+                r#
+                (assoc ~opts
+                       :client-id (:client-id @frontend.state/state))))))))))

src/main/frontend/persist_db/browser.cljs

@@ -9,7 +9,6 @@
             [frontend.config :as config]
             [frontend.date :as date]
             [frontend.db :as db]
-            [frontend.db.transact :as db-transact]
             [frontend.handler.notification :as notification]
             [frontend.handler.worker :as worker-handler]
             [frontend.persist-db.protocol :as protocol]
@@ -129,11 +128,10 @@
             (ldb/register-transact-fn!
              (fn worker-transact!
                [repo tx-data tx-meta]
-               (db-transact/transact transact!
-                                     (if (string? repo) repo (state/get-current-repo))
-                                     tx-data
-                                     (assoc tx-meta :client-id (:client-id @state/state)))))
-            (db-transact/listen-for-requests))
+               (transact!
+                (if (string? repo) repo (state/get-current-repo))
+                tx-data
+                (assoc tx-meta :client-id (:client-id @state/state))))))
           (p/catch (fn [error]
                      (prn :debug "Can't init SQLite wasm")
                      (js/console.error error)))))))

src/main/frontend/worker/db_listener.cljs

@@ -26,8 +26,7 @@
           tx-report' (:tx-report result)]
       (when result
         (let [data (merge
-                    {:request-id (:request-id tx-meta)
-                     :repo repo
+                    {:repo repo
                      :tx-data (:tx-data tx-report')
                      :tx-meta tx-meta}
                     (dissoc result :tx-report))]

src/main/frontend/worker/db_worker.cljs

@@ -629,15 +629,11 @@
 
 (def-thread-api :thread-api/apply-outliner-ops
   [repo ops opts]
-  (log/info ::apply-outliner-ops ops)
-  (log/info ::before-tx-id (:max-tx (worker-state/get-datascript-conn repo)))
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (try
       (worker-util/profile
        "apply outliner ops"
        (outliner-op/apply-ops! repo conn ops (worker-state/get-date-formatter repo) opts))
-      (when (worker-state/mobile?)
-        (log/info ::after-tx-id (:max-tx @conn)))
       (catch :default e
         (let [data (ex-data e)
               {:keys [type payload]} (when (map? data) data)]

src/main/mobile/init.cljs

@@ -65,7 +65,6 @@
   "NOTE: don't add more logic in this listener, use mobile-flows instead"
   [^js state]
   (log/info :app-state-change-handler state
-            :current-graph (state/get-current-repo)
             :app-active? (.-isActive state)
             :worker-client-id @state/*db-worker-client-id)
   (when (state/get-current-repo)