fix: property and property value selection for query builder

for db graphs

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

@@ -12,7 +12,6 @@
             [frontend.state :as state]
             [frontend.util :as util]
             [logseq.shui.ui :as shui]
-            [frontend.search :as search]
             [frontend.mixins :as mixins]
             [logseq.graph-parser.db :as gp-db]
             [rum.core :as rum]
@@ -20,7 +19,9 @@
             [logseq.common.util :as common-util]
             [logseq.common.util.page-ref :as page-ref]
             [promesa.core :as p]
-            [frontend.config :as config]))
+            [frontend.config :as config]
+            [logseq.db.frontend.property :as db-property]
+            [logseq.db.sqlite.util :as sqlite-util]))
 
 (rum/defc page-block-selector
   [*find]
@@ -41,7 +42,10 @@
    (select items on-chosen {}))
   ([items on-chosen options]
    (component-select/select (merge
-                             {:items (map #(hash-map :value %) items)
+                             ;; Allow caller to build :items
+                             {:items (if (map? (first items))
+                                       items
+                                       (map #(hash-map :value %) items))
                               :on-chosen on-chosen}
                              options))))
 
@@ -134,24 +138,40 @@
   (let [[properties set-properties!] (rum/use-state nil)]
     (rum/use-effect!
      (fn []
-       (p/let [properties (search/get-all-properties)]
+       (p/let [properties (db-async/<get-all-properties)]
          (set-properties! properties)))
      [])
-    (select properties
-            (fn [{:keys [value]}]
+    (select (map #(hash-map :db/ident (:db/ident %)
+                            :value (:block/original-name %))
+                 properties)
+            (fn [{value :value db-ident :db/ident}]
               (reset! *mode "property-value")
-              (reset! *property (keyword value))))))
+              (reset! *property (if (config/db-based-graph? (state/get-current-repo))
+                                  db-ident
+                                  (keyword value)))))))
 
 (rum/defc property-value-select
   [repo *property *find *tree opts loc]
-  (let [[values set-values!] (rum/use-state nil)]
+  (let [db-graph? (sqlite-util/db-based-graph? repo)
+        [values set-values!] (rum/use-state nil)]
     (rum/use-effect!
      (fn []
-       (p/let [result (db-async/<get-property-values repo @*property)]
+       (p/let [result (if db-graph?
+                        (db-async/<get-block-property-values repo @*property)
+                        (db-async/<file-get-property-values repo @*property))]
+         (when db-graph?
+           (doseq [db-id result]
+            (db-async/<get-block repo db-id :children? false)))
          (set-values! result)))
      [@*property])
-    (let [values (cons "Select all" values)]
-      (select values
+    (let [;; FIXME: lazy load property values consistently on first call
+          _ (when db-graph?
+              (doseq [id values] (db/sub-block id)))
+          values' (if db-graph?
+                   (map #(db-property/get-property-value-name (db/entity repo %)) values)
+                   values)
+          values'' (cons "Select all" values')]
+      (select values''
               (fn [{:keys [value]}]
                 (let [x (if (= value "Select all")
                           [(if (= @*find :page) :page-property :property) @*property]

src/main/frontend/db/async.cljs

@@ -16,6 +16,7 @@
             [cljs-time.format :as tf]
             [logseq.db :as ldb]
             [frontend.util :as util]
+            [frontend.handler.file-based.property.util :as property-util]
             [logseq.db.frontend.property :as db-property]))
 
 (def <q db-async-util/<q)
@@ -63,21 +64,27 @@
                        (db-property/logseq-property? (:db/ident %))
                        (not (get-in % [:block/schema :public?])))))))
 
-(defn <get-all-property-names
-  "Returns a seq of property name strings"
+(defn <get-all-properties
+  "Returns all public properties as property maps including their
+  :block/original-name and :db/ident. For file graphs the map only contains
+  :block/original-name"
   []
   (when-let [graph (state/get-current-repo)]
     (if (config/db-based-graph? graph)
-      (p/let [properties (<db-based-get-all-properties graph)]
-        (map :block/original-name properties))
-      (file-async/<file-based-get-all-properties graph))))
+      (<db-based-get-all-properties graph)
+      (p/let [properties (file-async/<file-based-get-all-properties graph)
+              hidden-properties (set (map name (property-util/hidden-properties)))]
+        (remove #(hidden-properties (:block/original-name %)) properties)))))
 
-(defn <get-property-values
+(defn <file-get-property-values
+  "For file graphs, returns property value names for given property name"
   [graph property]
   (when-not (config/db-based-graph? graph)
     (file-async/<get-file-based-property-values graph property)))
 
 (defn <get-block-property-values
+  "For db graphs, returns property value ids for given property db-ident.
+   Separate from file version because values are lazy loaded"
   [graph property-id]
   (let [empty-id (:db/id (db/entity :logseq.property/empty-placeholder))]
     (<q graph {:transact-db? false}

src/main/frontend/db/file_based/async.cljs

@@ -18,7 +18,8 @@
          (apply concat)
          distinct
          sort
-         (map name))))
+         (map name)
+         (map #(hash-map :block/original-name %)))))
 
 (defn- property-value-for-refs-and-text
   "Given a property value's refs and full text, determines the value to

src/main/frontend/search.cljs

@@ -11,8 +11,6 @@
             [frontend.search.fuzzy :as fuzzy]
             [logseq.common.config :as common-config]
             [frontend.db.async :as db-async]
-            [frontend.config :as config]
-            [frontend.handler.file-based.property.util :as property-util]
             [cljs-bean.core :as bean]
             [frontend.db :as db]
             [frontend.db.model :as db-model]
@@ -69,23 +67,14 @@
            (let [result (fuzzy/fuzzy-search (keys templates) q {:limit limit})]
              (vec (select-keys templates result)))))))))
 
-(defn get-all-properties
-  []
-  (when-let [repo (state/get-current-repo)]
-    (let [hidden-props (if (config/db-based-graph? repo)
-                         ;; no-op since already removed
-                         (constantly false)
-                         (set (map name (property-util/hidden-properties))))]
-      (p/let [properties (db-async/<get-all-property-names)]
-        (remove hidden-props properties)))))
-
 (defn property-search
   ([q]
    (property-search q 100))
   ([q limit]
    (when q
      (p/let [q (fuzzy/clean-str q)
-             properties (get-all-properties)]
+             properties* (db-async/<get-all-properties)
+             properties (map :block/original-name properties*)]
        (when (seq properties)
          (if (string/blank? q)
            properties
@@ -100,7 +89,7 @@
    (when-let [repo (state/get-current-repo)]
      (when q
       (p/let [q (fuzzy/clean-str q)
-              result (db-async/<get-property-values repo (keyword property))]
+              result (db-async/<file-get-property-values repo (keyword property))]
         (when (seq result)
           (if (string/blank? q)
             result