fix: reactive journals

src/main/frontend/components/journal.cljs

@@ -1,7 +1,9 @@
 (ns frontend.components.journal
   (:require [frontend.components.page :as page]
             [frontend.components.views :as views]
-            [frontend.hooks :as hooks]
+            [frontend.db-mixins :as db-mixins]
+            [frontend.db.react :as react]
+            [frontend.state :as state]
             [frontend.ui :as ui]
             [frontend.util :as util]
             [goog.dom :as gdom]
@@ -15,23 +17,29 @@
      {:class "journal-last-item"})
    (page/page-cp {:db/id id})])
 
-(rum/defc all-journals
+(defn- sub-journals
   []
-  (let [[data set-data!] (hooks/use-state nil)]
-    (hooks/use-effect!
-     (fn []
-       (p/let [{:keys [data]} (views/<load-view-data nil {:journals? true})]
-         (set-data! (remove nil? data))))
-     [])
-    [:div#journals
-     (ui/virtualized-list
-      {:custom-scroll-parent (gdom/getElement "main-content-container")
-       :increase-viewport-by {:top 300 :bottom 300}
-       :compute-item-key (fn [idx]
-                           (let [id (util/nth-safe data idx)]
-                             (str "journal-" id)))
-       :total-count (count data)
-       :item-content (fn [idx]
-                       (let [id (util/nth-safe data idx)
-                             last? (= (inc idx) (count data))]
-                         (journal-cp id last?)))})]))
+  (-> (react/q (state/get-current-repo)
+               [:frontend.worker.react/journals]
+               {:async-query-fn (fn []
+                                  (p/let [{:keys [data]} (views/<load-view-data nil {:journals? true})]
+                                    (remove nil? data)))}
+               nil)
+      util/react))
+
+(rum/defc all-journals < rum/reactive db-mixins/query
+  []
+  (let [data (sub-journals)]
+    (when (seq data)
+      [:div#journals
+       (ui/virtualized-list
+        {:custom-scroll-parent (gdom/getElement "main-content-container")
+         :increase-viewport-by {:top 300 :bottom 300}
+         :compute-item-key (fn [idx]
+                             (let [id (util/nth-safe data idx)]
+                               (str "journal-" id)))
+         :total-count (count data)
+         :item-content (fn [idx]
+                         (let [id (util/nth-safe data idx)
+                               last? (= (inc idx) (count data))]
+                           (journal-cp id last?)))})])))

src/main/frontend/db/react.cljs

@@ -42,12 +42,13 @@
   (reset! query-state {}))
 
 (defn add-q!
-  [k query inputs result-atom transform-fn query-fn inputs-fn]
+  [k query inputs result-atom transform-fn query-fn async-query-fn inputs-fn]
   (swap! query-state assoc k {:query query
                               :inputs inputs
                               :result result-atom
                               :transform-fn transform-fn
                               :query-fn query-fn
+                              :async-query-fn async-query-fn
                               :inputs-fn inputs-fn})
   result-atom)
 
@@ -85,14 +86,16 @@
     (:result result)))
 
 (defn- <q-aux
-  [repo db query-fn inputs-fn k query inputs]
+  [repo db query-fn async-query-fn inputs-fn k query inputs]
   (let [kv? (and (vector? k) (= :kv (second k)))
-        journals? (and (vector? k) (= :frontend.worker.react/journals (last k)))
-        q (if (or journals? util/node-test?)
+        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))))]
-    (when (or query-fn query kv?)
+    (when (or query-fn async-query-fn query kv?)
       (cond
+        async-query-fn
+        (async-query-fn)
+
         query-fn
         (query-fn db nil)
 
@@ -110,7 +113,7 @@
         (q query nil)))))
 
 (defn q
-  [repo k {:keys [use-cache? transform-fn 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?]
            :or {use-cache? true
                 transform-fn identity}} query & inputs]
   ;; {:pre [(s/valid? :frontend.worker.react/block k)]}
@@ -125,9 +128,9 @@
         (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 inputs-fn k query inputs)]
+                p-or-value (<q-aux repo db query-fn async-query-fn inputs-fn k query inputs)]
             (when-not disable-reactive?
-              (add-q! k query inputs result-atom transform-fn query-fn inputs-fn))
+              (add-q! k query inputs result-atom transform-fn query-fn async-query-fn inputs-fn))
             (cond
               return-promise?
               p-or-value
@@ -159,9 +162,9 @@
         (ldb/get-page (conn/get-db) page)))))
 
 (defn- execute-query!
-  [graph db k {:keys [query inputs transform-fn query-fn inputs-fn result]
+  [graph db k {:keys [query inputs transform-fn query-fn async-query-fn inputs-fn result]
                :or {transform-fn identity}}]
-  (p/let [p-or-value (<q-aux graph db 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)
           result' (transform-fn p-or-value)]
     (when-not (= result' result)
       (set-new-result! k result'))))

src/main/frontend/worker/react.cljs

@@ -1,8 +1,8 @@
 (ns frontend.worker.react
   "Compute reactive query affected keys"
-  (:require [datascript.core :as d]
-            [logseq.common.util :as common-util]
-            [cljs.spec.alpha :as s]))
+  (:require [cljs.spec.alpha :as s]
+            [datascript.core :as d]
+            [logseq.common.util :as common-util]))
 
 ;;; keywords specs for reactive query, used by `react/q` calls
 ;; ::block
@@ -41,9 +41,15 @@
                                     (:db/id (:block/page (d/entity db-after (:e datom))))))) tx-data)
                   (map :v)
                   (distinct))
-        tags (->> (filter (fn [datom] (contains? #{:block/tags} (:a datom))) tx-data)
+        tags (->> (filter (fn [datom] (= :block/tags (:a datom))) tx-data)
                   (map :v)
                   (distinct))
+        journals? (some (fn [datom]
+                          (and
+                           (= :block/tags (:a datom))
+                           (= (:db/id (d/entity db-after :logseq.class/Journal))
+                              (:v datom))))
+                        tx-data)
         other-blocks (->> (filter (fn [datom] (= "block" (namespace (:a datom)))) tx-data)
                           (map :e))
         blocks (-> (concat blocks other-blocks) distinct)
@@ -79,7 +85,11 @@
                        (keep
                         (fn [tag]
                           (when tag [::objects tag]))
-                        tags))]
+                        tags)
+
+                       (when journals?
+                         [[::journals]]))]
+    (prn :debug :affected-keys affected-keys)
     (->>
      affected-keys
      (remove nil?)