chore: address most of the large vars in db dep

deps/db/bb.edn

@@ -42,5 +42,5 @@
 
  :tasks/config
  {:large-vars
-  {:max-lines-count 60
+  {:max-lines-count 50
    :metadata-exceptions #{:large-vars/doc-var :large-vars/cleanup-todo}}}}

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

@@ -150,6 +150,23 @@
                    pages)]
     ref-pages))
 
+(defn- build-page-graph-other-page-links [db other-pages* show-journal]
+  (let [other-pages (->> other-pages*
+                         (remove nil?)
+                         (set))]
+    (mapcat
+     (fn [page-id]
+       (let [ref-pages (-> (get-page-referenced-pages db page-id)
+                           (set)
+                           (set/intersection other-pages))
+             mentioned-pages (-> (get-pages-that-mentioned-page db page-id show-journal)
+                                 (set)
+                                 (set/intersection other-pages))]
+         (concat
+          (map (fn [p] [page-id p]) ref-pages)
+          (map (fn [p] [p page-id]) mentioned-pages))))
+     other-pages)))
+
 (defn- build-page-graph
   [db page-uuid theme show-journal]
   (let [dark? (= "dark" theme)
@@ -171,21 +188,7 @@
                (map (fn [tag]
                       [page-id tag])
                     tags))
-        other-pages (->> (concat ref-pages mentioned-pages)
-                         (remove nil?)
-                         (set))
-        other-pages-links (mapcat
-                           (fn [page-id]
-                             (let [ref-pages (-> (get-page-referenced-pages db page-id)
-                                                 (set)
-                                                 (set/intersection other-pages))
-                                   mentioned-pages (-> (get-pages-that-mentioned-page db page-id show-journal)
-                                                       (set)
-                                                       (set/intersection other-pages))]
-                               (concat
-                                (map (fn [p] [page-id p]) ref-pages)
-                                (map (fn [p] [p page-id]) mentioned-pages))))
-                           other-pages)
+        other-pages-links (build-page-graph-other-page-links db (concat ref-pages mentioned-pages) show-journal)
         links (->> (concat links other-pages-links)
                    (remove nil?)
                    (distinct)

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

@@ -158,7 +158,7 @@
       (with-raw-title entity)
       (assoc :db/id (:db/id entity))))
 
-(defn get-block-and-children
+(defn ^:large-vars/cleanup-todo get-block-and-children
   [db id {:keys [children? children-only? nested-children? including-property-vals? properties children-props]
           :or {including-property-vals? true}}]
   (let [block (d/entity db (if (uuid? id)

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

@@ -350,6 +350,21 @@
    (map :e)
    set))
 
+(defn- get-entities-for-all-pages [db sorting property-ident {:keys [db-based?]}]
+  (let [refs-count? (and (coll? sorting) (some (fn [m] (= (:id m) :block.temp/refs-count)) sorting))
+        exclude-ids (when db-based? (get-exclude-page-ids db))]
+    (keep (fn [d]
+            (let [e (d/entity db (:e d))]
+              (when-not (if db-based?
+                          (exclude-ids (:db/id e))
+                          (or (ldb/hidden-or-internal-tag? e)
+                              (entity-util/property? e)
+                              (entity-util/built-in? e)))
+                (cond-> e
+                  refs-count?
+                  (assoc :block.temp/refs-count (count (:block/_refs e)))))))
+          (d/datoms db :avet property-ident))))
+
 (defn- get-entities
   [db view feat-type property-ident view-for-id* sorting]
   (let [view-for (:logseq.property/view-for view)
@@ -360,19 +375,7 @@
         db-based? (entity-plus/db-based-graph? db)]
     (case feat-type
       :all-pages
-      (let [refs-count? (and (coll? sorting) (some (fn [m] (= (:id m) :block.temp/refs-count)) sorting))
-            exclude-ids (when db-based? (get-exclude-page-ids db))]
-        (keep (fn [d]
-                (let [e (d/entity db (:e d))]
-                  (when-not (if db-based?
-                              (exclude-ids (:db/id e))
-                              (or (ldb/hidden-or-internal-tag? e)
-                                  (entity-util/property? e)
-                                  (entity-util/built-in? e)))
-                    (cond-> e
-                      refs-count?
-                      (assoc :block.temp/refs-count (count (:block/_refs e)))))))
-              (d/datoms db :avet property-ident)))
+      (get-entities-for-all-pages db sorting property-ident {:db-based? db-based?})
 
       :class-objects
       (let [class-id view-for-id