fix: cleanup to process all retracted entities (including pages)

related to logseq/db-test#726
related to logseq/db-test#752

Author: tiensonqin

deps/db/src/logseq/db/common/delete_blocks.cljs

@@ -46,24 +46,23 @@
      refs)))
 
 (defn update-refs-history
-  "When a block is deleted, a block's refs are updated and related property history, views and reactions
+  "When an entity is deleted, related property history, views and reactions
    are deleted"
   [db txs _opts]
-  (let [retracted-block-ids (->> (keep (fn [tx]
-                                         (when (and (vector? tx)
-                                                    (contains? #{:db.fn/retractEntity :db/retractEntity} (first tx)))
-                                           (second tx))) txs)
-                                 (filter (fn [id]
-                                           (not (entity-util/page? (d/entity db id))))))]
-    (when (seq retracted-block-ids)
-      (let [retracted-blocks (map #(d/entity db %) retracted-block-ids)
-            reaction-entities (->> retracted-blocks
+  (let [retracted-ids (keep (fn [tx]
+                              (when (and (vector? tx)
+                                         (contains? #{:db.fn/retractEntity :db/retractEntity} (first tx)))
+                                (second tx))) txs)
+        retracted-entities (map #(d/entity db %) retracted-ids)]
+    (when (seq retracted-ids)
+      (let [retracted-blocks (remove entity-util/page? retracted-entities)
+            reaction-entities (->> retracted-entities
                                    (mapcat :logseq.property.reaction/_target)
                                    (common-util/distinct-by :db/id))
             retract-reactions-tx (map (fn [reaction] [:db/retractEntity (:db/id reaction)])
                                       reaction-entities)
             retracted-tx (build-retracted-tx retracted-blocks)
-            history-entities (->> retracted-blocks
+            history-entities (->> retracted-entities
                                   (mapcat (fn [e]
                                             (concat (:logseq.property.history/_block e)
                                                     (:logseq.property.history/_ref-value e))))
@@ -75,6 +74,6 @@
                            (fn [item]
                              (let [block (d/entity db (:db/id item))]
                                (:logseq.property/_view-for block)))
-                           retracted-blocks)
+                           retracted-entities)
                           (map (fn [b] [:db/retractEntity (:db/id b)])))]
         (concat retracted-tx delete-views retract-history-tx retract-reactions-tx)))))

deps/db/test/logseq/db/common/delete_blocks_test.cljs

@@ -2,6 +2,7 @@
   (:require [cljs.test :refer [deftest is testing]]
             [datascript.core :as d]
             [logseq.common.util :as common-util]
+            [logseq.db :as ldb]
             [logseq.db.common.delete-blocks :as delete-blocks]
             [logseq.db.test.helper :as db-test]))
 
@@ -47,3 +48,24 @@
           extra (delete-blocks/update-refs-history @conn retracts {})]
       (d/transact! conn (concat retracts extra))
       (is (nil? (d/entity @conn (:db/id history-entity)))))))
+
+(deftest delete-page-removes-history-with-ref-value
+  (testing "deleting a page retracts property history entries that referenced that page"
+    (let [conn (db-test/create-conn-with-blocks
+                {:pages-and-blocks
+                 [{:page {:block/title "Journal"}
+                   :blocks [{:block/title "b1"}]}
+                  {:page {:block/title "Page to delete"}}]})
+          block (db-test/find-block-by-content @conn "b1")
+          page (db-test/find-page-by-title @conn "Page to delete")
+          history-uuid (random-uuid)
+          now (common-util/time-ms)
+          _ (d/transact! conn [{:block/uuid history-uuid
+                                :block/created-at now
+                                :block/updated-at now
+                                :logseq.property.history/block (:db/id block)
+                                :logseq.property.history/property (:db/id (d/entity @conn :logseq.property/status))
+                                :logseq.property.history/ref-value (:db/id page)}])
+          history-entity (d/entity @conn [:block/uuid history-uuid])]
+      (ldb/transact! conn [[:db/retractEntity (:db/id page)]])
+      (is (nil? (d/entity @conn (:db/id history-entity)))))))