fix: transit doesn't support entity

deps/db/src/logseq/db.cljs

@@ -10,7 +10,8 @@
             [clojure.set :as set]
             [logseq.db.frontend.rules :as rules]
             [logseq.db.frontend.entity-plus]
-            [logseq.db.frontend.class :as db-class]))
+            [logseq.db.frontend.class :as db-class]
+            [logseq.db.sqlite.util :as sqlite-util]))
 
 ;; Use it as an input argument for datalog queries
 (def block-attrs
@@ -565,6 +566,9 @@
          (built-in? property-entity)
          (contains? class-properties (:block/name property-entity)))))
 
+(def write-transit-str sqlite-util/write-transit-str)
+(def read-transit-str sqlite-util/read-transit-str)
+
 (comment
   (defn db-based-graph?
     "Whether the current graph is db-only"

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

@@ -3,7 +3,9 @@
   (:require [clojure.string :as string]
             [logseq.db.frontend.schema :as db-schema]
             [logseq.common.util :as common-util]
-            [cognitect.transit :as transit]))
+            [cognitect.transit :as transit]
+            [datascript.transit :as dt]
+            [datascript.impl.entity :as de]))
 
 (defonce db-version-prefix "logseq_db_")
 (defonce file-version-prefix "logseq_local_")
@@ -18,6 +20,18 @@
   [str]
   (transit/read transit-r str))
 
+(defn write-transit-str [o]
+  (let [write-handlers (assoc dt/write-handlers
+                              de/Entity (transit/write-handler (constantly "datascript/Entity")
+                                                         (fn [entity]
+                                                           (assert (some? (:db/id entity)))
+                                                           {:db/id (:db/id entity)})))]
+    (transit/write (transit/writer :json {:handlers write-handlers}) o)))
+
+(defn read-transit-str [s]
+  (let [read-handlers (assoc dt/read-handlers
+                             "datascript/Entity" identity)]
+    (transit/read (transit/reader :json {:handlers read-handlers}) s)))
 
 (defn db-based-graph?
   [graph-name]

src/main/frontend/db/async.cljs

@@ -16,7 +16,7 @@
             [frontend.date :as date]
             [cljs-time.core :as t]
             [cljs-time.format :as tf]
-            [datascript.transit :as dt]))
+            [logseq.db :as ldb]))
 
 (def <q db-async-util/<q)
 (def <pull db-async-util/<pull)
@@ -148,7 +148,7 @@
       (when-let [^Object sqlite @db-browser/*worker]
         (state/update-state! :db/async-queries (fn [s] (conj s name')))
         (p/let [result (.get-block-and-children sqlite graph name' children?)
-                {:keys [block children] :as result'} (dt/read-transit-str result)
+                {:keys [block children] :as result'} (ldb/read-transit-str result)
                 conn (db/get-db graph false)
                 block-and-children (cons block children)
                 _ (d/transact! conn block-and-children)]
@@ -165,7 +165,7 @@
   (assert (integer? db-id))
   (when-let [^Object worker @db-browser/*worker]
     (p/let [result-str (.get-right-sibling worker graph db-id)
-            result (dt/read-transit-str result-str)
+            result (ldb/read-transit-str result-str)
             conn (db/get-db graph false)
             _ (when result (d/transact! conn [result]))]
       result)))
@@ -177,7 +177,7 @@
     (when-let [block-id (:block/uuid (db/entity graph id))]
       (state/update-state! :db/async-queries (fn [s] (conj s (str block-id "-parents"))))
       (p/let [result-str (.get-block-parents worker graph id depth)
-              result (dt/read-transit-str result-str)
+              result (ldb/read-transit-str result-str)
               conn (db/get-db graph false)
               _ (d/transact! conn result)]
         (state/update-state! :db/async-queries (fn [s] (disj s (str block-id "-parents"))))
@@ -189,7 +189,7 @@
   (when-let [^Object worker @db-browser/*worker]
     (state/update-state! :db/async-queries (fn [s] (conj s (str eid "-refs"))))
     (p/let [result-str (.get-block-refs worker graph eid)
-            result (dt/read-transit-str result-str)
+            result (ldb/read-transit-str result-str)
             conn (db/get-db graph false)
             _ (d/transact! conn result)]
       (state/update-state! :db/async-queries (fn [s] (disj s (str eid "-refs"))))

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

@@ -4,15 +4,15 @@
             [promesa.core :as p]
             [frontend.db.conn :as db-conn]
             [datascript.core :as d]
-            [datascript.transit :as dt]))
+            [logseq.db :as ldb]))
 
 (defn <q
   [graph & inputs]
   (assert (not-any? fn? inputs) "Async query inputs can't include fns because fn can't be serialized")
   (when-let [^Object sqlite @state/*db-worker]
-    (p/let [result (.q sqlite graph (dt/write-transit-str inputs))]
+    (p/let [result (.q sqlite graph (ldb/write-transit-str inputs))]
       (when result
-        (let [result' (dt/read-transit-str result)]
+        (let [result' (ldb/read-transit-str result)]
           (when (and (seq result') (coll? result'))
             (when-let [conn (db-conn/get-db graph false)]
               (let [tx-data (->>
@@ -34,9 +34,9 @@
    (<pull graph '[*] id))
   ([graph selector id]
    (when-let [^Object sqlite @state/*db-worker]
-     (p/let [result (.pull sqlite graph (dt/write-transit-str selector) (dt/write-transit-str id))]
+     (p/let [result (.pull sqlite graph (ldb/write-transit-str selector) (ldb/write-transit-str id))]
        (when result
-         (let [result' (dt/read-transit-str result)]
+         (let [result' (ldb/read-transit-str result)]
            (when-let [conn (db-conn/get-db graph false)]
              (d/transact! conn [result']))
            result'))))))
@@ -46,6 +46,6 @@
    [graph selector ids]
    (assert (seq ids))
    (when-let [^Object sqlite @state/*db-worker]
-     (p/let [result (.pull-many sqlite graph (dt/write-transit-str selector) (dt/write-transit-str ids))]
+     (p/let [result (.pull-many sqlite graph (ldb/write-transit-str selector) (ldb/write-transit-str ids))]
        (when result
-         (dt/read-transit-str result))))))
+         (ldb/read-transit-str result))))))

src/main/frontend/db_worker.cljs

@@ -282,43 +282,43 @@
   (q [_this repo inputs-str]
      "Datascript q"
      (when-let [conn (worker-state/get-datascript-conn repo)]
-       (let [inputs (dt/read-transit-str inputs-str)
+       (let [inputs (ldb/read-transit-str inputs-str)
              result (apply d/q (first inputs) @conn (rest inputs))]
-         (dt/write-transit-str result))))
+         (ldb/write-transit-str result))))
 
   (pull
    [_this repo selector-str id-str]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [selector (dt/read-transit-str selector-str)
-           id (dt/read-transit-str id-str)
+     (let [selector (ldb/read-transit-str selector-str)
+           id (ldb/read-transit-str id-str)
            result (->> (d/pull @conn selector id)
                        (sqlite-common-db/with-parent-and-left @conn))]
-       (dt/write-transit-str result))))
+       (ldb/write-transit-str result))))
 
   (pull-many
    [_this repo selector-str ids-str]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [selector (dt/read-transit-str selector-str)
-           ids (dt/read-transit-str ids-str)
+     (let [selector (ldb/read-transit-str selector-str)
+           ids (ldb/read-transit-str ids-str)
            result (d/pull-many @conn selector ids)]
-       (dt/write-transit-str result))))
+       (ldb/write-transit-str result))))
 
   (get-right-sibling
    [_this repo db-id]
    (when-let [conn (worker-state/get-datascript-conn repo)]
      (let [result (ldb/get-right-sibling @conn db-id)]
-       (dt/write-transit-str result))))
+       (ldb/write-transit-str result))))
 
   (get-block-and-children
    [_this repo name children?]
    (assert (string? name))
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (dt/write-transit-str (sqlite-common-db/get-block-and-children @conn name children?))))
+     (ldb/write-transit-str (sqlite-common-db/get-block-and-children @conn name children?))))
 
   (get-block-refs
    [_this repo id]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (dt/write-transit-str (ldb/get-block-refs @conn id))))
+     (ldb/write-transit-str (ldb/get-block-refs @conn id))))
 
   (get-block-refs-count
    [_this repo id]
@@ -331,13 +331,13 @@
      (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)))))]
-       (dt/write-transit-str parents))))
+       (ldb/write-transit-str parents))))
 
   (get-page-unlinked-refs
    [_this repo page-id search-result-eids-str]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (let [search-result-eids (dt/read-transit-str search-result-eids-str)]
-       (dt/write-transit-str (ldb/get-page-unlinked-refs @conn page-id search-result-eids)))))
+     (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)))))
 
   (transact
    [_this repo tx-data tx-meta context]
@@ -345,13 +345,13 @@
    (when-let [conn (worker-state/get-datascript-conn repo)]
      (try
        (let [tx-data (if (string? tx-data)
-                       (dt/read-transit-str tx-data)
+                       (ldb/read-transit-str tx-data)
                        tx-data)
              tx-meta (if (string? tx-meta)
-                       (dt/read-transit-str tx-meta)
+                       (ldb/read-transit-str tx-meta)
                        tx-meta)
              context (if (string? context)
-                       (dt/read-transit-str context)
+                       (ldb/read-transit-str context)
                        context)
              _ (when context (worker-state/set-context! context))
              tx-meta' (if (:new-graph? tx-meta)
@@ -379,7 +379,7 @@
   (getInitialData
    [_this repo]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (dt/write-transit-str (sqlite-common-db/get-initial-data @conn))))
+     (ldb/write-transit-str (sqlite-common-db/get-initial-data @conn))))
 
   (fetch-all-pages
    [_this repo]
@@ -488,7 +488,7 @@
      (let [ops (edn/read-string ops-str)
            opts (edn/read-string opts-str)
            result (outliner-op/apply-ops! repo conn ops (worker-state/get-date-formatter repo) opts)]
-       (dt/write-transit-str result))))
+       (ldb/write-transit-str result))))
 
   (file-writes-finished?
    [this repo]
@@ -514,7 +514,7 @@
 
   (sync-app-state
    [this new-state-str]
-   (let [new-state (dt/read-transit-str new-state-str)]
+   (let [new-state (ldb/read-transit-str new-state-str)]
      (worker-state/set-new-state! new-state)
      nil))
 
@@ -523,18 +523,18 @@
    [this repo block-uuid-or-page-name tree->file-opts context]
    (when-let [conn (worker-state/get-datascript-conn repo)]
      (worker-export/block->content repo @conn block-uuid-or-page-name
-                                   (dt/read-transit-str tree->file-opts)
-                                   (dt/read-transit-str context))))
+                                   (ldb/read-transit-str tree->file-opts)
+                                   (ldb/read-transit-str context))))
 
   (get-all-pages
    [this repo]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (dt/write-transit-str (worker-export/get-all-pages repo @conn))))
+     (ldb/write-transit-str (worker-export/get-all-pages repo @conn))))
 
   (get-all-page->content
    [this repo]
    (when-let [conn (worker-state/get-datascript-conn repo)]
-     (dt/write-transit-str (worker-export/get-all-page->content repo @conn))))
+     (ldb/write-transit-str (worker-export/get-all-page->content repo @conn))))
 
   ;; RTC
   (rtc-start

src/main/frontend/handler/editor.cljs

@@ -68,7 +68,7 @@
             [rum.core :as rum]
             [frontend.handler.db-based.property :as db-property-handler]
             [frontend.fs.capacitor-fs :as capacitor-fs]
-            [datascript.transit :as dt]))
+            [logseq.db :as ldb]))
 
 ;; FIXME: should support multiple images concurrently uploading
 
@@ -2133,7 +2133,7 @@
                                                                            :replace-empty-target? replace-empty-target?
                                                                            :keep-uuid? keep-uuid?}))))]
       (state/set-block-op-type! nil)
-      (when result (edit-last-block-after-inserted! (dt/read-transit-str result))))))
+      (when result (edit-last-block-after-inserted! (ldb/read-transit-str result))))))
 
 (defn- block-tree->blocks
   "keep-uuid? - maintain the existing :uuid in tree vec"
@@ -2240,7 +2240,7 @@
                                    (save-current-block!))
                                  (outliner-op/insert-blocks! blocks' target
                                                              (assoc opts :sibling? sibling?')))]
-                   (when result (edit-last-block-after-inserted! (dt/read-transit-str result))))
+                   (when result (edit-last-block-after-inserted! (ldb/read-transit-str result))))
 
                  (catch :default ^js/Error e
                    (notification/show!

src/main/frontend/handler/events.cljs

@@ -82,7 +82,7 @@
             [frontend.modules.outliner.pipeline :as pipeline]
             [electron.ipc :as ipc]
             [frontend.date :as date]
-            [datascript.transit :as dt]))
+            [logseq.db :as ldb]))
 
 ;; TODO: should we move all events here?
 
@@ -976,8 +976,8 @@
 
     (when (util/electron?)
       (ipc/ipc :db-transact repo
-               (dt/write-transit-str (:tx-data data))
-               (dt/write-transit-str (:tx-meta data))))
+               (ldb/write-transit-str (:tx-data data))
+               (ldb/write-transit-str (:tx-meta data))))
 
     nil))
 

src/main/frontend/handler/worker.cljs

@@ -5,8 +5,8 @@
             [frontend.handler.notification :as notification]
             [frontend.state :as state]
             [promesa.core :as p]
-            [datascript.transit :as dt]
-            [frontend.util :as util]))
+            [frontend.util :as util]
+            [logseq.db :as ldb]))
 
 (defmulti handle identity)
 
@@ -54,6 +54,6 @@
                   (js/console.error "Unexpected webworker error:" (-> data bean/->clj (get-in [:value :value])))
                   (js/console.error "Unexpected webworker error:" data))
                 (if (string? data)
-                  (let [[e payload] (util/profile "UI read transit: " (dt/read-transit-str data))]
+                  (let [[e payload] (util/profile "UI read transit: " (ldb/read-transit-str data))]
                     (handle (keyword e) wrapped-worker payload))
                   (js/console.error "Worker received invalid data from worker: " data))))))))

src/main/frontend/persist_db/browser.cljs

@@ -38,12 +38,12 @@
                                  (not= (:config prev) (:config current))
                                  (assoc :config (:config current)))]
                  (when (seq new-state)
-                   (.sync-app-state worker (dt/write-transit-str new-state)))))))
+                   (.sync-app-state worker (ldb/write-transit-str new-state)))))))
 
 (defn transact!
   [^js worker repo tx-data tx-meta]
-  (let [tx-meta' (dt/write-transit-str tx-meta)
-        tx-data' (dt/write-transit-str tx-data)
+  (let [tx-meta' (ldb/write-transit-str tx-meta)
+        tx-data' (ldb/write-transit-str tx-data)
         ;; TODO: a better way to share those information with worker, maybe using the state watcher to notify the worker?
         context {:dev? config/dev?
                  :node-test? util/node-test?
@@ -59,7 +59,7 @@
                  :pages-directory (config/get-pages-directory)}]
     (if worker
       (.transact worker repo tx-data' tx-meta'
-                 (dt/write-transit-str context))
+                 (ldb/write-transit-str context))
       (notification/show! "Latest change was not saved! Please restart the application." :error))))
 
 (defn start-db-worker!
@@ -74,7 +74,7 @@
       (reset! *worker wrapped-worker)
       (-> (p/let [_ (.init wrapped-worker config/RTC-WS-URL)
                   _ (.sync-app-state wrapped-worker
-                                     (dt/write-transit-str
+                                     (ldb/write-transit-str
                                       {:git/current-repo (state/get-current-repo)
                                        :config (:config @state/state)}))
                   _ (sync-app-state! wrapped-worker)

src/main/frontend/search.cljs

@@ -18,7 +18,7 @@
             [frontend.db :as db]
             [frontend.db.model :as db-model]
             [frontend.db.utils :as db-utils]
-            [datascript.transit :as dt]))
+            [logseq.db :as ldb]))
 
 (def fuzzy-search fuzzy/fuzzy-search)
 
@@ -145,8 +145,8 @@
             result (block-search repo q {:limit 100})
             eids (map (fn [b] [:block/uuid (:block/uuid b)]) result)
             result (when (seq eids)
-                     (.get-page-unlinked-refs ^Object @state/*db-worker repo (:db/id page) (dt/write-transit-str eids)))
-            result' (when result (dt/read-transit-str result))]
+                     (.get-page-unlinked-refs ^Object @state/*db-worker repo (:db/id page) (ldb/write-transit-str eids)))
+            result' (when result (ldb/read-transit-str result))]
       (when result' (db/transact! repo result'))
       (some->> result'
                db-model/sort-by-left-recursive

src/main/frontend/worker/util.cljc

@@ -7,7 +7,7 @@
             [logseq.common.util :as common-util]
             [clojure.core.async :as async]
             [cljs.core.async.impl.channels :refer [ManyToManyChannel]]
-            [datascript.transit :as dt])))
+            [logseq.db :as ldb])))
 
 ;; Copied from https://github.com/tonsky/datascript-todo
 #?(:clj
@@ -93,4 +93,4 @@
      (defn post-message
        [type data]
        (when (exists? js/self)
-         (.postMessage js/self (frontend.worker.util/profile "Worker write transit: " (dt/write-transit-str [type data])))))))
+         (.postMessage js/self (frontend.worker.util/profile "Worker write transit: " (ldb/write-transit-str [type data])))))))