refactor: show linked refs and unlinked refs for blocks too

deps/db/src/logseq/db.cljs

@@ -383,22 +383,22 @@
       ;; only return the first result for idiot-proof
     (first (:block/_alias (d/entity db alias-id)))))
 
-(defn get-page-alias
-  [db page-id]
+(defn get-block-alias
+  [db eid]
   (->>
    (d/q
     '[:find [?e ...]
-      :in $ ?page %
+      :in $ ?eid %
       :where
-      (alias ?page ?e)]
+      (alias ?eid ?e)]
     db
-    page-id
+    eid
     (:alias rules/rules))
    distinct))
 
-(defn get-page-refs
+(defn get-block-refs
   [db id]
-  (let [alias (->> (get-page-alias db id)
+  (let [alias (->> (get-block-alias db id)
                    (cons id)
                    distinct)
         refs (->> (mapcat (fn [id] (:block/_path-refs (d/entity db id))) alias)
@@ -406,14 +406,6 @@
     (when (seq refs)
       (d/pull-many db '[*] (map :db/id refs)))))
 
-(defn get-block-refs
-  [db id]
-  (let [block (d/entity db id)]
-    (if (:block/name block)
-      (get-page-refs db id)
-      (let [refs (:block/_refs (d/entity db id))]
-        (when (seq refs)
-          (d/pull-many db '[*] (map :db/id refs)))))))
 
 (defn get-block-refs-count
   [db id]
@@ -424,7 +416,7 @@
 (defn get-page-unlinked-refs
   "Get unlinked refs from search result"
   [db page-id search-result-eids]
-  (let [alias (->> (get-page-alias db page-id)
+  (let [alias (->> (get-block-alias db page-id)
                    (cons page-id)
                    set)
         eids (remove

src/main/frontend/components/block.cljs

@@ -2637,7 +2637,10 @@
        (when-not (:table? config)
          (block-refs-count block refs-count *hide-block-refs?))]
 
-      (when (and (not (:table? config)) (not hide-block-refs?) (> refs-count 0))
+      (when (and (not (:table? config))
+                 (not hide-block-refs?)
+                 (> refs-count 0)
+                 (not= (str (:id config)) (str (:block/uuid block))))
         (when-let [refs-cp (state/get-component :block/linked-references)]
           (refs-cp uuid)))]]))
 

src/main/frontend/components/page.cljs

@@ -580,19 +580,17 @@
               (class-component/class-children page))
 
             ;; referenced blocks
-            (when-not block-or-whiteboard?
-              (when (and page (not (false? linked-refs?)))
-                [:div {:key "page-references"}
-                 (rum/with-key
-                   (reference/references page)
-                   (str route-page-name "-refs"))]))
+            (when-not (or whiteboard? linked-refs?)
+              [:div {:key "page-references"}
+               (rum/with-key
+                 (reference/references page)
+                 (str route-page-name "-refs"))])
 
             (when-not block-or-whiteboard?
               (when (and (not journal?) (not db-based?))
                 (hierarchy/structures route-page-name)))
 
-            (when (and (not (false? unlinked-refs?))
-                       (not (or block-or-whiteboard? sidebar? home?)))
+            (when-not (or whiteboard? unlinked-refs? sidebar? home?)
               [:div {:key "page-unlinked-references"}
                (reference/unlinked-references page)])])]))))
 

src/main/frontend/components/reference.cljs

@@ -29,11 +29,8 @@
   [block-id]
   (when-let [e (db/entity [:block/uuid block-id])]
     (when-not (state/sub-async-query-loading (str (:db/id e) "-refs"))
-      (let [page? (some? (:block/name e))
-            ref-blocks (if page?
-                         (-> (db/get-page-referenced-blocks (:db/id e))
-                             db-utils/group-by-page)
-                         (db/get-block-referenced-blocks (:db/id e)))]
+      (let [ref-blocks (-> (db/get-referenced-blocks (:db/id e))
+                           db-utils/group-by-page)]
         (when (> (count ref-blocks) 0)
           (let [ref-hiccup (block/->hiccup ref-blocks
                                            {:id (str block-id)
@@ -47,11 +44,11 @@
                               {:hiccup ref-hiccup})]))))))
 
 (rum/defc references-inner
-  [page-name filters filtered-ref-blocks]
+  [page-entity filters filtered-ref-blocks]
   (let [*ref (rum/use-ref nil)]
     [:div.references-blocks.faster.fade-in {:ref *ref}
     (let [ref-hiccup (block/->hiccup filtered-ref-blocks
-                                     {:id page-name
+                                     {:id (:block/title page-entity)
                                       :scroll-container *ref
                                       :ref? true
                                       :breadcrumb-show? true
@@ -59,10 +56,10 @@
                                       :editor-box editor/box
                                       :filters filters}
                                      {})]
-      (content/content page-name {:hiccup ref-hiccup}))]))
+      (content/content (:block/title page-entity) {:hiccup ref-hiccup}))]))
 
 (rum/defc references-cp
-  [page-entity page-name *filters total filter-n filtered-ref-blocks *ref-pages]
+  [page-entity *filters total filter-n filtered-ref-blocks *ref-pages]
   (let [filters @*filters
         threshold (state/get-linked-references-collapsed-threshold)
         default-collapsed? (or (>= total threshold) (ldb/class? page-entity))
@@ -98,7 +95,7 @@
                           :size  22})]]
 
      (fn []
-       (references-inner page-name filters filtered-ref-blocks))
+       (references-inner page-entity filters filtered-ref-blocks))
 
      {:default-collapsed? default-collapsed?
       :title-trigger? true
@@ -119,22 +116,24 @@
             (concat children (rest blocks))
             (conj result fb))))))))
 
-(rum/defc references-aux <
+(rum/defc references-aux < rum/reactive db-mixins/query
   {:should-update (fn [old-state new-state]
                     ;; Re-render if only filters update
                     (not= (last (:rum/args old-state))
                           (last (:rum/args new-state))))}
   [state repo page-entity *filters filters]
-  (let [page-name (:block/name page-entity)
-        *ref-pages (::ref-pages state)
+  (let [*ref-pages (::ref-pages state)
         page-id (:db/id page-entity)
-        ref-blocks (db/get-page-referenced-blocks page-id)
+        ref-blocks (db/get-referenced-blocks page-id)
+        _ (prn :debug :ref-blocks ref-blocks)
         aliases (db/page-alias-set repo page-id)
         aliases-exclude-self (set (remove #{page-id} aliases))
         top-level-blocks (filter (fn [b] (some aliases (set (map :db/id (:block/refs b))))) ref-blocks)
         top-level-blocks-ids (set (map :db/id top-level-blocks))
         filtered-ref-blocks (->> (block-handler/filter-blocks ref-blocks filters)
                                  (block-handler/get-filtered-ref-blocks-with-parents ref-blocks))
+        _ (prn :debug :ref-blocks ref-blocks
+               :filtered-ref-blocks filtered-ref-blocks)
         total (count top-level-blocks)
         filtered-top-blocks (filter (fn [b] (top-level-blocks-ids (:db/id b))) filtered-ref-blocks)
         filter-n (count filtered-top-blocks)
@@ -164,7 +163,7 @@
     (when (or (seq (:included filters)) (seq (:excluded filters)) (> filter-n 0))
       [:div.references.page-linked.flex-1.flex-row
        [:div.content.pt-6
-        (references-cp page-entity page-name *filters total filter-n filtered-ref-blocks' *ref-pages)]])))
+        (references-cp page-entity *filters total filter-n filtered-ref-blocks' *ref-pages)]])))
 
 (rum/defcs references* < rum/reactive db-mixins/query
   (rum/local nil ::ref-pages)
@@ -172,25 +171,25 @@
            (let [page (first (:rum/args state))]
              (when page (db-async/<get-block-refs (state/get-current-repo) (:db/id page))))
            (assoc state ::filters (atom nil)))}
-  [state page-entity]
-  (when page-entity
+  [state block-entity]
+  (when block-entity
     (let [repo (state/get-current-repo)
           *filters (::filters state)]
-      (when page-entity
-        (when-not (state/sub-async-query-loading (str (:db/id page-entity) "-refs"))
-          (let [page-entity (db/sub-block (:db/id page-entity))
-                filters (page-handler/get-filters page-entity)
+      (when block-entity
+        (when-not (state/sub-async-query-loading (str (:db/id block-entity) "-refs"))
+          (let [block-entity (db/sub-block (:db/id block-entity))
+                filters (page-handler/get-filters block-entity)
                 _ (when-not (= filters @*filters)
                     (reset! *filters filters))]
-            (references-aux state repo page-entity *filters filters)))))))
+            (references-aux state repo block-entity *filters filters)))))))
 
 (rum/defc references
-  [page-entity]
+  [entity]
   (ui/catch-error
    (ui/component-error (if (config/db-based-graph? (state/get-current-repo))
                          "Linked References: Unexpected error."
                          "Linked References: Unexpected error. Please re-index your graph first."))
-   (references* page-entity)))
+   (references* entity)))
 
 (rum/defcs unlinked-references-aux
   < rum/reactive db-mixins/query
@@ -198,7 +197,7 @@
    (fn [state]
      (let [*result (atom nil)
            [page *n-ref] (:rum/args state)]
-       (p/let [result (search/get-page-unlinked-refs (:db/id page))]
+       (p/let [result (search/get-unlinked-refs (:db/id page))]
          (reset! *n-ref (count result))
          (reset! *result result))
        (assoc state ::result *result)))}

src/main/frontend/components/reference_filters.cljs

@@ -85,12 +85,13 @@
       [:input.cp__filters-input.w-full.bg-transparent
        {:placeholder (t :linked-references/filter-search)
         :autofocus true
-        :ref (fn [^js el] (-> (p/delay 32) (p/then #(.focus el))))
+        :ref (fn [^js el] (when el
+                            (-> (p/delay 32) (p/then #(.focus el)))))
         :on-change (fn [e]
                      (reset! filter-search (util/evalue e)))}]]
      (let [all-filters (set
-                         (concat (map :block/name included)
-                           (map :block/name excluded)))
+                        (concat (map :block/name included)
+                                (map :block/name excluded)))
            refs (remove (fn [[page _]] (all-filters (util/page-name-sanity-lc page)))
                         filtered-references)]
        (when (seq refs)

src/main/frontend/db.cljs

@@ -35,7 +35,7 @@
   get-files-blocks get-files-full get-journals-length
   get-latest-journals get-page get-case-page get-page-alias get-page-alias-names
   get-page-blocks-count get-page-blocks-no-cache get-page-file get-page-format
-  get-page-referenced-blocks get-page-referenced-blocks-full get-page-referenced-pages
+  get-referenced-blocks get-page-referenced-blocks-full get-page-referenced-pages
   get-all-pages get-pages-relation get-pages-that-mentioned-page
   journal-page? page? page-alias-set sub-block
   page-empty? page-exists? get-alias-source-page

src/main/frontend/db/model.cljs

@@ -200,7 +200,7 @@ independent of format as format specific heading characters are stripped"
 (defn page-alias-set
   [repo-url page-id]
   (->>
-   (ldb/get-page-alias (conn/get-db repo-url) page-id)
+   (ldb/get-block-alias (conn/get-db repo-url) page-id)
    (set)
    (set/union #{page-id})))
 
@@ -603,22 +603,23 @@ independent of format as format specific heading characters are stripped"
                            k)]
                    [k blocks])))))))))
 
-(defn get-page-referenced-blocks
-  ([page-id]
-   (get-page-referenced-blocks (state/get-current-repo) page-id nil))
-  ([page-id options]
-   (get-page-referenced-blocks (state/get-current-repo) page-id options))
-  ([repo page-id options]
+(defn get-referenced-blocks
+  ([eid]
+   (get-referenced-blocks (state/get-current-repo) eid nil))
+  ([eid options]
+   (get-referenced-blocks (state/get-current-repo) eid options))
+  ([repo eid options]
    (when repo
      (when (conn/get-db repo)
-       (let [page (db-utils/entity page-id)
-             pages (page-alias-set repo page-id)]
+       (let [entity (db-utils/entity eid)
+             page? (ldb/page? entity)
+             ids (page-alias-set repo eid)]
          (->>
           (react/q repo
-                   [:frontend.worker.react/refs page-id]
+                   [:frontend.worker.react/refs eid]
                    {:query-fn (fn []
                                 (let [entities (mapcat (fn [id]
-                                                         (:block/_path-refs (db-utils/entity id))) pages)
+                                                         (:block/_path-refs (db-utils/entity id))) ids)
                                       blocks (map (fn [e]
                                                     {:block/parent (:block/parent e)
                                                      :block/order (:block/order e)
@@ -630,33 +631,23 @@ independent of format as format specific heading characters are stripped"
           react
           :entities
           (remove (fn [block]
-                    (or (= page-id (:db/id (:block/page block)))
-                        (ldb/hidden-page? (:block/page block))
-                        (contains? (set (map :db/id (:block/tags block))) (:db/id page)))))
+                    (or
+                     (= (:db/id (:block/link block)) eid)
+                     (= (:db/id block) eid)
+                     (= eid (:db/id (:block/page block)))
+                     (ldb/hidden-page? (:block/page block))
+                     (contains? (set (map :db/id (:block/tags block))) (:db/id entity)))))
           (util/distinct-by :db/id)))))))
 
-;; TODO: no need to use datalog query, `:block/_refs`
 (defn get-block-referenced-blocks
   ([block-id]
    (get-block-referenced-blocks block-id {}))
   ([block-id options]
    (when-let [repo (state/get-current-repo)]
      (when (conn/get-db repo)
-       (let [block (db-utils/entity block-id)
-             query-result (->> (react/q repo [:frontend.worker.react/refs
-                                              (:db/id block)]
-                                        {}
-                                        '[:find [(pull ?ref-block ?block-attrs) ...]
-                                          :in $ ?block-id ?block-attrs
-                                          :where
-                                          [?ref-block :block/refs ?block-id]
-                                          [?ref-block :block/page ?p]
-                                          (not [?p :block/type "hidden"])]
-                                        block-id
-                                        block-attrs)
-                               react
-                               (sort-by-order-recursive))]
-         (db-utils/group-by-page query-result))))))
+       (->> (get-referenced-blocks repo block-id options)
+            (sort-by-order-recursive)
+            db-utils/group-by-page)))))
 
 (defn journal-page?
   "sanitized page-name only"

src/main/frontend/search.cljs

@@ -111,21 +111,22 @@
   (when-let [engine (get-engine repo)]
     (protocol/transact-blocks! engine data)))
 
-(defn get-page-unlinked-refs
+(defn get-unlinked-refs
   "Get matched result from search first, and then filter by worker db"
-  [page-id]
+  [eid]
   (when-let [repo (state/get-current-repo)]
-    (p/let [page (db/entity page-id)
+    (p/let [entity (db/entity eid)
             alias-names (conj (set (map util/safe-page-name-sanity-lc
-                                        (db/get-page-alias-names repo page-id)))
-                              (:block/title page))
+                                        (db/get-page-alias-names repo eid)))
+                              (:block/title entity))
             q (string/join " " alias-names)
             result (block-search repo q {:limit 100})
             eids (->> result
                       (remove :page?)
+                      (remove (fn [b] (= (:block/uuid b) (:block/uuid entity))))
                       (map (fn [b] [:block/uuid (:block/uuid b)])))
             result (when (seq eids)
-                     (.get-page-unlinked-refs ^Object @state/*db-worker repo (:db/id page) (ldb/write-transit-str eids)))
+                     (.get-page-unlinked-refs ^Object @state/*db-worker repo (:db/id entity) (ldb/write-transit-str eids)))
             result' (when result (ldb/read-transit-str result))]
       (when result' (d/transact! (db/get-db repo false) result'))
       (some->> result'

src/test/frontend/db/model_test.cljs

@@ -47,8 +47,8 @@
         a-aliases (model/page-alias-set test-helper/test-db aid)
         b-aliases (model/page-alias-set test-helper/test-db bid)
         alias-names (model/get-page-alias-names test-helper/test-db aid)
-        b-ref-blocks (model/get-page-referenced-blocks bid)
-        a-ref-blocks (model/get-page-referenced-blocks aid)]
+        b-ref-blocks (model/get-referenced-blocks bid)
+        a-ref-blocks (model/get-referenced-blocks aid)]
 
     (are [x y] (= x y)
       4 (count a-aliases)
@@ -67,7 +67,7 @@
   (let [page-id (:db/id (db/entity [:block/name "aa"]))
         a-aliases (model/page-alias-set test-helper/test-db page-id)
         alias-names (model/get-page-alias-names test-helper/test-db page-id)
-        a-ref-blocks (model/get-page-referenced-blocks page-id)]
+        a-ref-blocks (model/get-referenced-blocks page-id)]
     (are [x y] (= x y)
       3 (count a-aliases)
       2 (count a-ref-blocks)