perf: don't load block children if collapsed

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

@@ -146,7 +146,7 @@
         (d/pull-many db '[*] ids')))))
 
 (defn get-block-and-children
-  [db id {:keys [children? nested-children? including-property-vals? properties]
+  [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)
                              [:block/uuid id]
@@ -157,52 +157,48 @@
                            :block/tags :block/page]
         block-refs-count? (some #{:block.temp/refs-count} properties)]
     (when block
-      (let [block' (if (seq properties)
-                     (select-keys block properties)
-                     block)
-            block' (cond->
-                    (if (or children? nested-children?)
-                      (mark-block-fully-loaded block')
-                      block')
-                     including-property-vals?
-                     (update-vals (fn [v]
-                                    (cond
-                                      (de/entity? v)
-                                      (select-keys v property-value-ks)
+      (let [children (when (or children? children-only?)
+                       (let [page? (common-entity-util/page? block)
+                             children (cond
+                                        (and nested-children? (not page?))
+                                        (get-block-children db (:block/uuid block))
+                                        nested-children?
+                                        (:block/_page block)
+                                        :else
+                                        (let [short-page? (when page?
+                                                            (<= (count (:block/_page block)) 100))]
+                                          (if short-page?
+                                            (:block/_page block)
+                                            (:block/_parent block))))
+                             children-props (or children-props [:db/id :block/uuid :block/parent :block/order :block/collapsed?])]
+                         (map
+                          (fn [block]
+                            (select-keys block children-props))
+                          children)))]
+        (if children-only?
+          {:children children}
+          (let [block' (if (seq properties)
+                         (select-keys block properties)
+                         block)
+                block' (cond->
+                        (mark-block-fully-loaded block')
+                         including-property-vals?
+                         (update-vals (fn [v]
+                                        (cond
+                                          (de/entity? v)
+                                          (select-keys v property-value-ks)
 
-                                      (and (coll? v) (every? de/entity? v))
-                                      (map #(select-keys % property-value-ks) v)
+                                          (and (coll? v) (every? de/entity? v))
+                                          (map #(select-keys % property-value-ks) v)
 
-                                      :else
-                                      v)))
-                     block-refs-count?
-                     (assoc :block.temp/refs-count (count (:block/_refs block))))]
-        (cond->
-         {:block (assoc (into {} block') :db/id (:db/id block))}
-          children?
-          (assoc :children
-                 (let [page? (common-entity-util/page? block)
-                       children (if (and nested-children? (not page?))
-                                  (get-block-children db (:block/uuid block))
-                                  (if page?
-                                    (:block/_page block)
-                                    (:block/_parent block)))
-                       long-page? (and (> (count children) 500) (not (common-entity-util/whiteboard? block)))]
-                   (if long-page?
-                     (->> (map (fn [e]
-                                 (select-keys e [:db/id :block/uuid :block/page :block/order :block/parent :block/collapsed? :block/link]))
-                               children)
-                          (map #(with-block-link db %)))
-                     (->> (d/pull-many db '[*] (map :db/id children))
-                          (map #(with-block-refs db %))
-                          (map #(with-block-link db %))
-                          (mapcat (fn [block]
-                                    (let [e (d/entity db (:db/id block))]
-                                      (conj
-                                       (if (seq (:block/properties e))
-                                         (vec (property-with-values db e nil))
-                                         [])
-                                       block)))))))))))))
+                                          :else
+                                          v)))
+                         block-refs-count?
+                         (assoc :block.temp/refs-count (count (:block/_refs block))))]
+            (cond->
+             {:block (assoc (into {} block') :db/id (:db/id block))}
+              children?
+              (assoc :children children))))))))
 
 (defn get-latest-journals
   [db]

src/main/electron/listener.cljs

@@ -5,23 +5,23 @@
             [clojure.string :as string]
             [dommy.core :as dom]
             [electron.ipc :as ipc]
+            [frontend.db :as db]
+            [frontend.db.async :as db-async]
             [frontend.db.model :as db-model]
             [frontend.fs.sync :as sync]
             [frontend.fs.watcher-handler :as watcher-handler]
             [frontend.handler.file-sync :as file-sync-handler]
             [frontend.handler.notification :as notification]
+            [frontend.handler.property.util :as pu]
             [frontend.handler.route :as route-handler]
+            [frontend.handler.search :as search-handler]
             [frontend.handler.ui :as ui-handler]
             [frontend.handler.user :as user]
-            [frontend.handler.search :as search-handler]
             [frontend.state :as state]
             [frontend.ui :as ui]
             [logseq.common.path :as path]
             [logseq.common.util :as common-util]
-            [promesa.core :as p]
-            [frontend.handler.property.util :as pu]
-            [frontend.db :as db]
-            [frontend.db.async :as db-async]))
+            [promesa.core :as p]))
 
 (defn- safe-api-call
   "Force the callback result to be nil, otherwise, ipc calls could lead to
@@ -87,7 +87,7 @@
                          (route-handler/redirect-to-page! page-name {:block-id block-id}))
 
                        block-id
-                       (p/let [block (db-async/<get-block (state/get-current-repo) block-id)]
+                       (p/let [block (db-async/<get-block (state/get-current-repo) block-id {:children? false})]
                          (if block
                            (if (pu/shape-block? block)
                              (route-handler/redirect-to-page! (get-in block [:block/page :block/uuid]) {:block-id block-id})

src/main/frontend/components/block.cljs

@@ -3630,6 +3630,12 @@
                                    (select-keys (first (:rum/args new-state)) config-compare-keys)))]
     (boolean result)))
 
+(defn- set-collapsed-block!
+  [block-id v]
+  (if (false? v)
+    (editor-handler/expand-block! block-id {:skip-db-collpsing? true})
+    (state/set-collapsed-block! block-id v)))
+
 (rum/defcs loaded-block-container < rum/reactive db-mixins/query
   (rum/local false ::show-block-left-menu?)
   (rum/local false ::show-block-right-menu?)
@@ -3642,14 +3648,14 @@
              (cond
                (and (:page-title? config) (or (ldb/class? block) (ldb/property? block)) (not config/publishing?))
                (let [collapsed? (state/get-block-collapsed block-id)]
-                 (state/set-collapsed-block! block-id (if (some? collapsed?) collapsed? true)))
+                 (set-collapsed-block! block-id (if (some? collapsed?) collapsed? true)))
 
                (root-block? config block)
-               (state/set-collapsed-block! block-id false)
+               (set-collapsed-block! block-id false)
 
                (or (:ref? config) (:custom-query? config) (:view? config))
-               (state/set-collapsed-block! block-id
-                                           (boolean (editor-handler/block-default-collapsed? block config)))
+               (set-collapsed-block! block-id
+                                     (boolean (editor-handler/block-default-collapsed? block config)))
 
                :else
                nil)
@@ -3664,7 +3670,7 @@
                    (let [[config block] (:rum/args state)
                          block-id (:block/uuid block)]
                      (when (root-block? config block)
-                       (state/set-collapsed-block! block-id nil)))
+                       (set-collapsed-block! block-id nil)))
                    state)}
   [state config block & {:as opts}]
   (let [repo (state/get-current-repo)
@@ -3699,10 +3705,17 @@
       (hooks/use-effect!
        (fn []
          (p/do!
-          (db-async/<get-block (state/get-current-repo) (:db/id block*))
+          (db-async/<get-block (state/get-current-repo)
+                               (:db/id block*)
+                               {:children? (not
+                                            (if-some [result (state/get-block-collapsed (:block/uuid block))]
+                                              result
+                                              (:block/collapsed? block)))
+                                :skip-refresh? true})
           (set-block! (some-> (:db/id block*) db/entity))))
        []))
-    (loaded-block-container config block opts)))
+    (when (or (:view? config) (:block.temp/fully-loaded? block))
+      (loaded-block-container config block opts))))
 
 (defn divide-lists
   [[f & l]]

src/main/frontend/components/page.cljs

@@ -485,10 +485,11 @@
   [e *control-show? *all-collapsed?]
   (util/stop e)
   (reset! *control-show? true)
-  (let [all-collapsed?
-        (->> (editor-handler/all-blocks-with-level {:collapse? true})
-             (filter (fn [b] (editor-handler/collapsable? (:block/uuid b))))
-             (empty?))]
+  (p/let [blocks (editor-handler/<all-blocks-with-level {:collapse? true})
+          all-collapsed?
+          (->> blocks
+               (filter (fn [b] (editor-handler/collapsable? (:block/uuid b))))
+               (empty?))]
     (reset! *all-collapsed? all-collapsed?)))
 
 (defn- page-mouse-leave
@@ -670,7 +671,7 @@
                                         :preview? preview?})))
                (lsp-pagebar-slot)])
 
-            (when (and db-based? sidebar?)
+            (when (and db-based? sidebar? (ldb/page? page))
               [:div.-mb-8
                (sidebar-page-properties config page)])
 

src/main/frontend/components/property/config.cljs

@@ -757,8 +757,7 @@
                  repo (state/get-current-repo)
                  property (first (:rum/args state))
                  ident (:db/ident property)]
-             (p/let [_ (db-async/<get-block repo (:block/uuid property))
-                     result (db-async/<get-property-values ident)]
+             (p/let [result (db-async/<get-property-values ident)]
                (reset! *values result))
              (assoc state ::values *values)))}
   [state property* owner-block opts]

src/main/frontend/components/query/result.cljs

@@ -47,7 +47,8 @@
             (util/react (query-dsl/query (state/get-current-repo) q {:cards? (:cards? config)}))))
 
         :else
-        (util/react (query-custom/custom-query query {:current-block-uuid current-block-uuid})))
+        (util/react (query-custom/custom-query query {:current-block-uuid current-block-uuid
+                                                      :built-in-query? (:built-in-query? config)})))
       (catch :default e
         (reset! *query-error e)))))
 

src/main/frontend/components/views.cljs

@@ -579,7 +579,7 @@
         sized-columns (get-in table [:state :sized-columns])
         row-cell-f (fn [column {:keys [_lazy?]}]
                      (when-let [render (get column :cell)]
-                       (let [id (str row "-" (:id column))
+                       (let [id (str (:id row) "-" (:id column))
                              width (get-column-size column sized-columns)
                              select? (= (:id column) :select)
                              add-property? (= (:id column) :add-property)
@@ -1234,7 +1234,7 @@
           (let [[first-block-id blocks] row]
             [:div
              {:key (str "partition-" first-block-id)}
-             [:div.ml-2
+             [:div.ml-6.text-sm.opacity-70.hover:opacity-100.mt-1
               (breadcrumb (assoc config :list-view? true)
                           (state/get-current-repo) first-block-id
                           {:show-page? false})]

src/main/frontend/db/async.cljs

@@ -100,7 +100,7 @@
 
 (defonce *block-cache (atom (cache/lru-cache-factory {} :threshold 1000)))
 (defn <get-block
-  [graph id-uuid-or-name & {:keys [children? skip-transact? skip-refresh? block-only? _properties]
+  [graph id-uuid-or-name & {:keys [children? nested-children? skip-transact? skip-refresh? block-only? children-only? _properties]
                             :or {children? true}
                             :as opts}]
 
@@ -124,7 +124,9 @@
                (and (util/uuid-string? name') name')
                id-uuid-or-name)]
     (cond
-      (:block.temp/fully-loaded? e)
+      (and (:block.temp/fully-loaded? e) ; children may not be fully loaded
+           (not children-only?)
+           (not nested-children?))
       e
 
       cached-response
@@ -139,18 +141,23 @@
           (state/update-state! :db/async-query-loading (fn [s] (disj s name')))
           (if skip-transact?
             (reset! *block-cache (cache/miss @*block-cache cache-key
-                                             (if (or children? block-only?)
+                                             (if (and (not children-only?) (or children? block-only?))
                                                (:block result')
                                                result')))
             (let [conn (db/get-db graph false)
-                  block-and-children (cons block children)
-                  affected-keys [[:frontend.worker.react/block (:db/id block)]]]
-              (d/transact! conn (remove (fn [b] (:block.temp/fully-loaded? (db/entity (:db/id b)))) block-and-children))
+                  block-and-children (if block (cons block children) children)
+                  affected-keys [[:frontend.worker.react/block (:db/id block)]]
+                  tx-data (remove (fn [b] (:block.temp/fully-loaded? (db/entity (:db/id b)))) block-and-children)]
+              (when (seq tx-data) (d/transact! conn tx-data))
               (when-not skip-refresh?
                 (react/refresh-affected-queries! graph affected-keys))))
 
-          (if (or children? block-only?)
+          (cond
+            children-only?
+            children
+            (or children? block-only?)
             block
+            :else
             result'))))))
 
 (defn <get-blocks

src/main/frontend/db/react.cljs

@@ -86,11 +86,17 @@
     (:result result)))
 
 (defn- <q-aux
-  [repo db query-fn async-query-fn inputs-fn k query inputs]
+  [repo db query-fn async-query-fn inputs-fn k query inputs built-in-query?]
   (let [kv? (and (vector? k) (= :kv (second k)))
         q (if util/node-test?
             (fn [query inputs] (apply d/q query db inputs))
-            (fn [query inputs] (apply db-async-util/<q repo {} (cons query inputs))))]
+            (fn [query inputs]
+              (let [q-f #(apply db-async-util/<q repo {} (cons query inputs))]
+                (if built-in-query?
+                  ;; delay built-in-queries to not block journal rendering
+                  (p/let [_ (p/delay 100)]
+                    (q-f))
+                  (q-f)))))]
     (when (or query-fn async-query-fn query kv?)
       (cond
         async-query-fn
@@ -113,7 +119,8 @@
         (q query nil)))))
 
 (defn q
-  [repo k {:keys [use-cache? transform-fn query-fn async-query-fn inputs-fn disable-reactive? return-promise?]
+  [repo k {:keys [use-cache? transform-fn query-fn async-query-fn inputs-fn
+                  disable-reactive? return-promise? built-in-query?]
            :or {use-cache? true
                 transform-fn identity}} query & inputs]
   ;; {:pre [(s/valid? :frontend.worker.react/block k)]}
@@ -128,7 +135,7 @@
         (if (and use-cache? result-atom)
           result-atom
           (let [result-atom (or result-atom (atom nil))
-                p-or-value (<q-aux repo db query-fn async-query-fn inputs-fn k query inputs)]
+                p-or-value (<q-aux repo db query-fn async-query-fn inputs-fn k query inputs built-in-query?)]
             (when-not disable-reactive?
               (add-q! k query inputs result-atom transform-fn query-fn async-query-fn inputs-fn))
             (cond
@@ -162,9 +169,9 @@
         (ldb/get-page (conn/get-db) page)))))
 
 (defn- execute-query!
-  [graph db k {:keys [query inputs transform-fn query-fn async-query-fn inputs-fn result]
+  [graph db k {:keys [query inputs transform-fn query-fn async-query-fn inputs-fn result built-in-query?]
                :or {transform-fn identity}}]
-  (p/let [p-or-value (<q-aux graph db query-fn async-query-fn inputs-fn k query inputs)
+  (p/let [p-or-value (<q-aux graph db query-fn async-query-fn inputs-fn k query inputs built-in-query?)
           result' (transform-fn p-or-value)]
     (when-not (= result' result)
       (set-new-result! k result'))))

src/main/frontend/extensions/fsrs.cljs

@@ -1,6 +1,7 @@
 (ns frontend.extensions.fsrs
   "Flashcards functions based on FSRS, only works in db-based graphs"
   (:require [clojure.string :as string]
+            [frontend.common.missionary :as c.m]
             [frontend.components.block :as component-block]
             [frontend.config :as config]
             [frontend.context.i18n :refer [t]]
@@ -16,7 +17,6 @@
             [frontend.state :as state]
             [frontend.ui :as ui]
             [frontend.util :as util]
-            [frontend.common.missionary :as c.m]
             [logseq.db :as ldb]
             [logseq.db.frontend.entity-plus :as entity-plus]
             [logseq.shui.ui :as shui]
@@ -189,7 +189,7 @@
 (rum/defcs ^:private card-view < rum/reactive db-mixins/query
   {:will-mount (fn [state]
                  (when-let [[repo block-id _] (:rum/args state)]
-                   (db-async/<get-block repo block-id))
+                   (db-async/<get-block repo block-id {:children? false}))
                  state)}
   [state repo block-id *card-index *phase]
   (when-let [block-entity (db/sub-block block-id)]

src/main/frontend/handler/editor.cljs

@@ -3564,7 +3564,7 @@
                                    semantic?))))
          false)))))
 
-(defn all-blocks-with-level
+(defn <all-blocks-with-level
   "Return all blocks associated with correct level
    if :root-block is not nil, only return root block with its children
    if :expanded? true, return expanded children
@@ -3586,13 +3586,17 @@
   (when-let [page (or page
                       (state/get-current-page)
                       (date/today))]
-    (let [block-id (or root-block (parse-uuid page))
-          page-id (when-not block-id
-                    (:db/id (db/get-page page)))
-          blocks (if block-id
-                   (db/get-block-and-children (state/get-current-repo) block-id)
-                   (db/get-page-blocks-no-cache page-id))
-          root-block (or block-id root-block)]
+    (p/let [block-id (or root-block (parse-uuid page))
+            page-id (when-not block-id
+                      (:db/id (db/get-page page)))
+            repo (state/get-current-repo)
+            result (db-async/<get-block repo (or block-id page-id)
+                                        {:children-only? true
+                                         :nested-children? true})
+            blocks (if page-id
+                     result
+                     (cons (db/entity [:block/uuid block-id]) result))
+            root-block (or block-id root-block)]
       (if incremental?
         (let [blocks (tree/blocks->vec-tree blocks (or block-id page-id))]
           (->>
@@ -3661,10 +3665,13 @@
       (set-blocks-collapsed! [block-id] true))
     (state/set-collapsed-block! block-id true)))
 
-(defn expand-block! [block-id]
-  (when-not (skip-collapsing-in-db?)
-    (set-blocks-collapsed! [block-id] false))
-  (state/set-collapsed-block! block-id false))
+(defn expand-block! [block-id & {:keys [skip-db-collpsing?]}]
+  (let [repo (state/get-current-repo)]
+    (p/do!
+     (db-async/<get-block repo block-id {:children-only? true})
+     (when-not (or skip-db-collpsing? (skip-collapsing-in-db?))
+       (set-blocks-collapsed! [block-id] false))
+     (state/set-collapsed-block! block-id false))))
 
 (defn expand!
   ([e] (expand! e false))
@@ -3690,8 +3697,8 @@
 
      :else
      ;; expand one level
-     (let [blocks-with-level (all-blocks-with-level {})
-           max-level (or (apply max (map :block/level blocks-with-level)) 99)]
+     (p/let [blocks-with-level (<all-blocks-with-level {})
+             max-level (or (apply max (map :block/level blocks-with-level)) 99)]
        (loop [level 1]
          (if (> level max-level)
            nil
@@ -3727,9 +3734,9 @@
 
      :else
      ;; collapse by one level from outside
-     (let [blocks-with-level
-           (all-blocks-with-level {:collapse? true})
-           max-level (or (apply max (map :block/level blocks-with-level)) 99)]
+     (p/let [blocks-with-level
+             (<all-blocks-with-level {:collapse? true})
+             max-level (or (apply max (map :block/level blocks-with-level)) 99)]
        (loop [level max-level]
          (if (zero? level)
            nil
@@ -3784,74 +3791,79 @@
    (collapse-all! nil {}))
   ([block-id {:keys [collapse-self?]
               :or {collapse-self? true}}]
-   (let [blocks (all-blocks-with-level {:incremental? false
-                                        :expanded? true
-                                        :root-block block-id})
-         block-ids (cond->> (mapv :block/uuid blocks)
-                     (not collapse-self?)
-                     (remove #{block-id}))]
+   (p/let [blocks (<all-blocks-with-level {:incremental? false
+                                           :expanded? true
+                                           :root-block block-id})
+           block-ids (cond->> (mapv :block/uuid blocks)
+                       (not collapse-self?)
+                       (remove #{block-id}))]
      (set-blocks-collapsed! block-ids true))))
 
 (defn expand-all!
   ([]
    (expand-all! nil))
   ([block-id]
-   (let [blocks (all-blocks-with-level {:incremental? false
-                                        :collapse? true
-                                        :root-block block-id})
-         block-ids (map :block/uuid blocks)]
+   (p/let [blocks (<all-blocks-with-level {:incremental? false
+                                           :collapse? true
+                                           :root-block block-id})
+           block-ids (map :block/uuid blocks)]
      (set-blocks-collapsed! block-ids false))))
 
 (defn collapse-all-selection!
   []
-  (let [block-ids (->> (get-selected-toplevel-block-uuids)
-                       (map #(all-blocks-with-level {:incremental? false
-                                                     :expanded? true
-                                                     :root-block %}))
-                       flatten
-                       (map :block/uuid)
-                       distinct)]
+  (p/let [blocks (p/all
+                  (map #(<all-blocks-with-level {:incremental? false
+                                                 :expanded? true
+                                                 :root-block %})
+                       (get-selected-toplevel-block-uuids)))
+          block-ids (->> blocks
+                         (map :block/uuid)
+                         distinct)]
     (set-blocks-collapsed! block-ids true)))
 
 (defn expand-all-selection!
   []
-  (let [block-ids (->> (get-selected-toplevel-block-uuids)
-                       (map #(all-blocks-with-level {:incremental? false
-                                                     :collapse? true
-                                                     :root-block %}))
-                       flatten
+  (let [blocks (p/all
+                (map #(<all-blocks-with-level {:incremental? false
+                                               :expanded? true
+                                               :root-block %})
+                     (get-selected-toplevel-block-uuids)))
+        block-ids (->> blocks
                        (map :block/uuid)
                        distinct)]
     (set-blocks-collapsed! block-ids false)))
 
 (defn toggle-open! []
-  (let [all-expanded? (empty? (all-blocks-with-level {:incremental? false
-                                                      :collapse? true}))]
+  (p/let [blocks (<all-blocks-with-level {:incremental? false
+                                          :collapse? true})
+          all-expanded? (empty? blocks)]
     (if all-expanded?
       (collapse-all!)
       (expand-all!))))
 
 (defn toggle-open-block-children! [block-id]
-  (let [all-expanded? (empty? (all-blocks-with-level {:incremental? false
-                                                      :collapse? true
-                                                      :root-block block-id}))]
+  (p/let [blocks (<all-blocks-with-level {:incremental? false
+                                          :collapse? true})
+          all-expanded? (empty? blocks)]
     (if all-expanded?
       (collapse-all! block-id {:collapse-self? false})
       (expand-all! block-id))))
 
 (defn select-all-blocks!
   [{:keys [page]}]
-  (if-let [current-input-id (state/get-edit-input-id)]
-    (let [input (gdom/getElement current-input-id)
-          blocks-container (util/rec-get-blocks-container input)
-          blocks (dom/by-class blocks-container "ls-block")]
-      (state/exit-editing-and-set-selected-blocks! blocks))
-    (->> (all-blocks-with-level {:page page
-                                 :collapse? true})
-         (map (fn [b] (or (some-> (:db/id (:block/link b)) db/entity) b)))
-         (map (comp gdom/getElementByClass (fn [b] (str "id" (:block/uuid b)))))
-         state/exit-editing-and-set-selected-blocks!))
-  (state/set-state! :selection/selected-all? true))
+  (p/do!
+   (if-let [current-input-id (state/get-edit-input-id)]
+     (let [input (gdom/getElement current-input-id)
+           blocks-container (util/rec-get-blocks-container input)
+           blocks (dom/by-class blocks-container "ls-block")]
+       (state/exit-editing-and-set-selected-blocks! blocks))
+     (p/let [blocks (<all-blocks-with-level {:page page
+                                             :collapse? true})]
+       (->> blocks
+            (map (fn [b] (or (some-> (:db/id (:block/link b)) db/entity) b)))
+            (map (comp gdom/getElementByClass (fn [b] (str "id" (:block/uuid b)))))
+            state/exit-editing-and-set-selected-blocks!)))
+   (state/set-state! :selection/selected-all? true)))
 
 (defn select-parent [e]
   (let [edit-input (some-> (state/get-edit-input-id) gdom/getElement)

src/main/frontend/mobile/deeplink.cljs

@@ -1,8 +1,8 @@
 (ns frontend.mobile.deeplink
   (:require
    [clojure.string :as string]
-   [goog :refer [Uri]]
    [frontend.config :as config]
+   [frontend.db.async :as db-async]
    [frontend.db.model :as db-model]
    [frontend.handler.editor :as editor-handler]
    [frontend.handler.notification :as notification]
@@ -10,8 +10,8 @@
    [frontend.mobile.intent :as intent]
    [frontend.state :as state]
    [frontend.util.text :as text-util]
+   [goog :refer [Uri]]
    [logseq.common.util :as common-util]
-   [frontend.db.async :as db-async]
    [promesa.core :as p]))
 
 (def *link-to-another-graph (atom false))
@@ -59,7 +59,7 @@
                    (editor-handler/insert-first-page-block-if-not-exists! db-page-name))
 
                  block-uuid
-                 (p/let [block (db-async/<get-block (state/get-current-repo) block-uuid)]
+                 (p/let [block (db-async/<get-block (state/get-current-repo) block-uuid {:children? false})]
                    (if block
                      (route-handler/redirect-to-page! block-uuid)
                      (notification/show! (str "Open link failed. Block-id `" block-uuid "` doesn't exist in the graph."

src/main/logseq/api.cljs

@@ -718,7 +718,9 @@
 (defn- <ensure-page-loaded
   [block-uuid-or-page-name]
   (p/let [repo (state/get-current-repo)
-          result (db-async/<get-block repo (str block-uuid-or-page-name))
+          result (db-async/<get-block repo (str block-uuid-or-page-name)
+                                      {:children-props '[*]
+                                       :nested-children? true})
           block (if (:block result) (:block result) result)
           _ (when-let [page-id (:db/id (:block/page block))]
               (when-let [page-uuid (:block/uuid (db/entity page-id))]