test(rtc): entity-datoms=>ops

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

@@ -446,7 +446,7 @@
               (and (contains? attr-map :link)
                    (:block/uuid (:block/link block)))
               (assoc :link (:block/uuid (:block/link block)))
-              true (assoc :target-uuid target-uuid :sibling? sibling?))])))
+              target-uuid                     (assoc :target-uuid target-uuid :sibling? sibling?))])))
 
 (defmethod local-block-ops->remote-ops-aux :update-page-op
   [_ & {:keys [repo block-uuid *remote-ops]}]
@@ -494,17 +494,16 @@
                                                :left-uuid left-uuid
                                                :block-uuid block-uuid
                                                :*remote-ops *remote-ops
-                                               :*depend-on-block-uuid-set *depend-on-block-uuid-set))
-
-            ;; remote-update-op
-            (when update-op
-              (local-block-ops->remote-ops-aux :update-op
-                                               :repo repo
-                                               :block block
-                                               :update-op update-op
-                                               :parent-uuid parent-uuid
-                                               :left-uuid left-uuid
-                                               :*remote-ops *remote-ops))))
+                                               :*depend-on-block-uuid-set *depend-on-block-uuid-set)))
+          ;; remote-update-op
+          (when update-op
+            (local-block-ops->remote-ops-aux :update-op
+                                             :repo repo
+                                             :block block
+                                             :update-op update-op
+                                             :parent-uuid parent-uuid
+                                             :left-uuid left-uuid
+                                             :*remote-ops *remote-ops)))
         ;; remote-update-page-op
         (when update-page-op
           (local-block-ops->remote-ops-aux :update-page-op

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

@@ -1,12 +1,11 @@
 (ns frontend.db.rtc.db-listener
   "listen datascript changes, infer operations from the db tx-report"
-  (:require [clojure.data :as data]
+  (:require [cljs-time.coerce :as tc]
+            [cljs-time.core :as t]
+            [clojure.data :as data]
             [clojure.set :as set]
             [datascript.core :as d]
-            [frontend.db :as db]
-            [frontend.db.rtc.op-mem-layer :as op-mem-layer]
-            [cljs-time.core :as t]
-            [cljs-time.coerce :as tc]))
+            [frontend.db.rtc.op-mem-layer :as op-mem-layer]))
 
 
 (defn- entity-datoms=>attr->datom
@@ -47,7 +46,7 @@
       (seq retract-uuids) (conj [:retract retract-uuids]))))
 
 (defn- entity-datoms=>ops
-  [repo db-before db-after entity-datoms]
+  [db-before db-after entity-datoms]
   (let [attr->datom (entity-datoms=>attr->datom entity-datoms)]
     (when (seq attr->datom)
       (let [updated-key-set (set (keys attr->datom))
@@ -127,7 +126,7 @@
                                        (apply merge))]
                     (cond-> ops (seq update-op) (conj [:update update-op]))))
             ops* (keep (fn [op]
-                         (let [block-uuid (some-> (db/entity repo e) :block/uuid str)]
+                         (let [block-uuid (some-> (d/entity db-after e) :block/uuid str)]
                            (case (first op)
                              :move        (when block-uuid ["move" {:block-uuid block-uuid}])
                              :update      (when block-uuid
@@ -145,7 +144,7 @@
         id->same-entity-datoms (group-by first datom-vec-coll)
         id-order (distinct (map first datom-vec-coll))
         same-entity-datoms-coll (map id->same-entity-datoms id-order)
-        ops (mapcat (partial entity-datoms=>ops repo db-before db-after) same-entity-datoms-coll)
+        ops (mapcat (partial entity-datoms=>ops db-before db-after) same-entity-datoms-coll)
         now-epoch*1000 (* 1000 (tc/to-long (t/now)))
         ops* (map-indexed (fn [idx op]
                             [(first op) (assoc (second op) :epoch (+ idx now-epoch*1000))]) ops)]

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

@@ -85,9 +85,10 @@
     [:current-branch ops-store-value-schema]
     [:old-branch {:optional true} [:maybe ops-store-value-schema]]]])
 
-(def ops-store-schema-validator (m/validator ops-store-schema))
+(def ops-store-schema-coercer (m/coercer ops-store-schema))
 
-(defonce ^:private *ops-store (atom {} :validator ops-store-schema-validator))
+
+(defonce ^:private *ops-store (atom {} :validator ops-store-schema-coercer))
 
 (defn- merge-add-retract-maps
   [m1 m2]

src/test/frontend/db/rtc/db_listener_test.cljs

@@ -0,0 +1,25 @@
+(ns frontend.db.rtc.db-listener-test
+  (:require [cljs.test :as t :refer [deftest is testing]]
+            [datascript.core :as d]
+            [frontend.db.rtc.db-listener :as subject]
+            [logseq.db.frontend.schema :as db-schema]))
+
+
+(def empty-db (d/empty-db db-schema/schema-for-db-based-graph))
+
+
+(deftest entity-datoms=>ops-test
+  (testing "remove whiteboard page-block"
+    (let [conn (d/conn-from-db empty-db)
+          block-uuid (random-uuid)
+          _create-whiteboard-page-block
+          (d/transact! conn [{:block/uuid block-uuid
+                              :block/type "whiteboard"
+                              :block/name "block-name"
+                              :block/original-name "BLOCK-NAME"}])
+          remove-whiteboard-page-block
+          (d/transact! conn [[:db/retractEntity [:block/uuid block-uuid]]])]
+      (is (= [["remove-page" {:block-uuid (str block-uuid)}]]
+             (#'subject/entity-datoms=>ops (:db-before remove-whiteboard-page-block)
+                                           (:db-after remove-whiteboard-page-block)
+                                           (map vec (:tx-data remove-whiteboard-page-block))))))))