WIP: use OPFS db for electron

deps/db/src/logseq/db/sqlite/db.cljs

@@ -107,17 +107,7 @@
           (upsert-addr-content! repo data)))
       (-restore [_ addr]
         (let [content (restore-data-from-addr repo addr)]
-          (edn/read-string content))
-        ;; disable cache for now
-        ;; (when-let [content (if (cache/has? cache addr)
-        ;;                      (do
-        ;;                        (cache/hit cache addr)
-        ;;                        (cache/lookup cache addr))
-        ;;                      (when-let [result (restore-data-from-addr repo addr)]
-        ;;                        (cache/miss cache addr result)
-        ;;                        result))]
-        ;;   (edn/read-string content))
-        ))))
+          (edn/read-string content))))))
 
 (defn open-db!
   [graphs-dir db-name]

src/main/frontend/db/persist.cljs

@@ -6,19 +6,15 @@
             [electron.ipc :as ipc]
             [frontend.db.conn :as db-conn]
             [promesa.core :as p]
-            [frontend.persist-db :as persist-db]))
+            [frontend.persist-db :as persist-db]
+            [cljs-bean.core :as bean]))
 
 (defn get-all-graphs
   []
-  (if (util/electron?)
-    (p/let [result (ipc/ipc "getGraphs")
-            result (vec result)
-            ;; backward compatibility (release <= 0.5.4)
-            result (if (seq result) result (idb/get-nfs-dbs))]
-      (distinct result))
-    (p/let [repos (idb/get-nfs-dbs)
-            db-repos (persist-db/<list-db)]
-      (concat repos db-repos))))
+  (p/let [repos (idb/get-nfs-dbs)
+          db-repos (persist-db/<list-db)
+          electron-disk-graphs (when (util/electron?) (ipc/ipc "getGraphs"))]
+    (distinct (concat repos db-repos (bean/->clj electron-disk-graphs)))))
 
 (defn get-serialized-graph
   [graph-name]
@@ -57,4 +53,3 @@
         (js/console.error "rename-graph! is not supported in electron")
         (idb/rename-item! old-key new-key))
       (idb/rename-item! old-key new-key))))
-

src/main/frontend/db_worker.cljs

@@ -10,7 +10,8 @@
             [logseq.db.frontend.schema :as db-schema]
             [shadow.cljs.modern :refer [defclass]]
             [datascript.transit :as dt]
-            [clojure.edn :as edn]))
+            [clojure.edn :as edn]
+            [clojure.string :as string]))
 
 (def *wasm-loaded (atom false))
 
@@ -51,6 +52,11 @@
         (let [content (restore-data-from-addr repo addr)]
           (edn/read-string content))))))
 
+(defn split-last [pattern s]
+  (when-let [last-index (string/last-index-of s pattern)]
+    [(subs s 0 last-index)
+     (subs s (+ last-index (count pattern)) (count s))]))
+
 #_:clj-kondo/ignore
 (defclass SQLiteDB
   (extends js/Object)
@@ -62,12 +68,14 @@
   Object
   (init
    [_this]
-   (p/let [wasm-url (js/URL. "/static/js/logseq_sqlite_bg.wasm" (.. js/location -href))
-           _ (wasm-bindgen-init wasm-url)]
-     (prn ::init-ok
-          :has-opfs-support (.has_opfs_support sqlite-db)
-          :sqlite-version (.get_version sqlite-db))
-     (reset! *wasm-loaded true)))
+   (let [[_ sqlite-wasm-url] (split-last "url=" (.. js/location -href))]
+     (assert (some? sqlite-wasm-url) "sqlite-wasm-url is empty")
+     (p/let [wasm-url (js/URL. sqlite-wasm-url (.. js/location -href))
+            _ (wasm-bindgen-init wasm-url)]
+      (prn ::init-ok
+           :has-opfs-support (.has_opfs_support sqlite-db)
+           :sqlite-version (.get_version sqlite-db))
+      (reset! *wasm-loaded true))))
 
   (inited
    [_this]

src/main/frontend/persist_db.cljs

@@ -1,25 +1,15 @@
 (ns frontend.persist-db
    "Backend of DB based graph"
    (:require [frontend.persist-db.browser :as browser]
-             [frontend.persist-db.node :as node]
              [frontend.persist-db.protocol :as protocol]
-             [frontend.util :as util]
              [promesa.core :as p]))
 
-
- (defonce electron-ipc-sqlite-db (node/->ElectronIPC))
-
- (defonce opfs-db (browser/->InBrowser))
+(defonce opfs-db (browser/->InBrowser))
 
  (defn- get-impl
-   "Get the actual implementation of PersistentDB"
-   []
-   (cond
-     (util/electron?)
-     electron-ipc-sqlite-db
-
-     :else
-     opfs-db))
+  "Get the actual implementation of PersistentDB"
+  []
+  opfs-db)
 
  (defn <list-db []
    (protocol/<list-db (get-impl)))
@@ -27,6 +17,7 @@
  (defn <unsafe-delete [repo]
    (protocol/<unsafe-delete (get-impl) repo))
 
+;; FIXME: limit repo name's length
 (defn <new [repo]
   {:pre [(<= (count repo) 56)]}
   (protocol/<new (get-impl) repo))

src/main/frontend/persist_db/browser.cljs

@@ -14,10 +14,16 @@
 (defonce *sqlite (atom nil))
 (defonce *inited (atom false))
 
-(when-not (or (util/electron?) config/publishing? util/node-test?)
+(when-not (or config/publishing? util/node-test?)
   (defonce _do_not_reload_worker
-    (let [worker (try
-                   (js/Worker. "/static/js/db-worker.js")
+    (let [worker-url (if (util/electron?)
+                       "js/db-worker.js"
+                       "/static/js/db-worker.js")
+          sqlite-url (if (util/electron?)
+                       "logseq_sqlite_bg.wasm"
+                       "/static/js/logseq_sqlite_bg.wasm")
+          worker (try
+                   (js/Worker. (str worker-url "?url=" sqlite-url))
                    (catch js/Error e
                      (js/console.error "worker error", e)
                      nil))
@@ -74,9 +80,12 @@
                    nil))))
 
   (<list-db [_this]
+    (prn :debug :ensure-sqlite-init (js/Date.))
     (-> (p/let [^js sqlite (ensure-sqlite-init)]
+          (prn :debug :list-db (js/Date.))
           (.listDB sqlite))
         (p/catch (fn [error]
+                   (prn :debug :list-db-error (js/Date.))
                    (notification/show! [:div (str "SQLiteDB error: " error)] :error)
                    []))))
 

src/main/frontend/persist_db/node.cljs

@@ -1,31 +0,0 @@
-(ns frontend.persist-db.node
-  "Electron ipc based persistent db"
-  (:require [cljs.core.async.interop :refer [p->c]]
-            [electron.ipc :as ipc]
-            [frontend.persist-db.protocol :as protocol]
-            [promesa.core :as p]))
-
-(defrecord ElectronIPC []
-  protocol/PersistentDB
-  (<new [_this repo]
-    (prn ::new repo)
-    (ipc/ipc :db-new repo))
-
-  (<list-db [_this]
-    (js/console.warn "TODO: list-db for electron is not implemented")
-    [])
-  (<unsafe-delete [_this _repo]
-    (js/console.warn "TODO: delete persidt-db on electron")
-    (p/resolved nil))
-  (<transact-data [_this repo tx-data tx-meta]
-    (p->c
-     (ipc/ipc :db-transact-data repo
-              (pr-str
-               {:tx-data tx-data
-                :tx-meta tx-meta}))))
-  (<fetch-initital-data [_this repo _opts]
-    (prn ::fetch-initial repo)
-    (ipc/ipc :get-initial-data repo))
-  (<fetch-blocks-excluding [_this repo exclude-uuids _opts]
-    (prn ::fetch-by-exclude repo exclude-uuids)
-    nil))