enhance: export tags for property values

deps/db/src/logseq/db/frontend/property/build.cljs

@@ -67,8 +67,10 @@
 
 (defn build-property-value-block
   "Builds a property value entity given a block map/entity, a property entity or
-  ident and its property value"
-  [block property value & {:keys [block-uuid property-value-properties]}]
+  ident and its property value. Takes the following options:
+   * :block-uuid - :block/uuid for property value entity
+   * :properties - Additional properties and attributes to add to entity"
+  [block property value & {:keys [block-uuid properties]}]
   (let [block-id (or (:db/id block) (:db/ident block))]
     (cond->
      (merge
@@ -87,8 +89,8 @@
         {:block/title value}))
       true
       common-util/block-with-timestamps
-      property-value-properties
-      (merge property-value-properties))))
+      properties
+      (merge properties))))
 
 (defn build-property-values-tx-m
   "Builds a map of property names to their property value blocks to be
@@ -114,7 +116,7 @@
                                  block' property-map %
                                  (cond-> {}
                                    property-value-properties
-                                   (assoc :property-value-properties property-value-properties)
+                                   (assoc :properties property-value-properties)
                                    pure?
                                    (assoc :block-uuid
                                           (common-uuid/gen-uuid :builtin-block-uuid (str gen-uuid-value-prefix "-" %)))))
@@ -122,7 +124,7 @@
                      (build-property-value-block block' property-map v
                                                  (cond-> {}
                                                    property-value-properties
-                                                   (assoc :property-value-properties property-value-properties)
+                                                   (assoc :properties property-value-properties)
                                                    pure?
                                                    (assoc :block-uuid
                                                           (common-uuid/gen-uuid :builtin-block-uuid (str gen-uuid-value-prefix "-" v))))))])))

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

@@ -128,11 +128,14 @@
   (->> properties
        (keep (fn [[k v]]
                (when-let [property-map (build-property-map-for-pvalue-tx k v new-block properties-config all-idents)]
-                 [(cond-> property-map
-                    (and (:build/property-value v)
-                         (or (:build/properties v) (seq (select-keys v [:block/created-at :block/updated-at]))))
-                    (assoc :property-value-properties
-                           (merge (:build/properties v) (select-keys v [:block/created-at :block/updated-at]))))
+                 [(let [pvalue-attrs (when (:build/property-value v)
+                                       (merge (:build/properties v)
+                                              {:block/tags (mapv #(hash-map :db/ident (get-ident all-idents %))
+                                                                 (:build/tags v))}
+                                              (select-keys v [:block/created-at :block/updated-at])))]
+                    (cond-> property-map
+                      (and (:build/property-value v) (seq pvalue-attrs))
+                      (assoc :property-value-properties pvalue-attrs)))
                   (if (:build/property-value v)
                     (or (:logseq.property/value v) (:block/title v))
                     v)])))

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

@@ -66,12 +66,16 @@
                     ent-properties (when (and (not (:block/closed-value-property pvalue)) (seq ent-properties*))
                                      ;; TODO: Support closed values as needed
                                      (buildable-properties db ent-properties* {} options))]
-                (if (seq ent-properties)
-                  (cond->
-                   {:build/property-value :block
-                    :block/title (or (block-title pvalue)
-                                     (:logseq.property/value pvalue))
-                    :build/properties ent-properties}
+                (if (or (seq ent-properties) (seq (:block/tags pvalue)))
+                  (cond-> {:build/property-value :block
+                           :block/title (or (block-title pvalue)
+                                            (:logseq.property/value pvalue))}
+                    (seq (:block/tags pvalue))
+                    (assoc :build/tags (->build-tags (:block/tags pvalue)))
+
+                    (seq ent-properties)
+                    (assoc :build/properties ent-properties)
+
                     (:include-timestamps? options)
                     (merge (select-keys pvalue [:block/created-at :block/updated-at])))
                   ;; nbb-compatible version of db-property/property-value-content

deps/db/test/logseq/db/sqlite/build_test.cljs

@@ -207,20 +207,41 @@
                 (map #(:block/title (d/entity @conn %)))))
         "Property page has correct blocks")))
 
-(deftest property-value-properties
+(deftest property-value-with-properties-and-tags
   (let [conn (db-test/create-conn-with-blocks
-              [{:page {:block/title "page1"}
-                :blocks [{:block/title "Todo query",
-                          :build/tags [:logseq.class/Query],
-                          :build/properties
-                          {:logseq.property/query
-                           {:build/property-value :block
-                            :block/title "{:query (task Todo)}"
-                            :build/properties
-                            {:logseq.property.code/lang "clojure"
-                             :logseq.property.node/display-type :code}}}}]}])]
+              {:properties {:p1 {:logseq.property/type :default}}
+               :classes {:C1 {}}
+               :pages-and-blocks
+               [{:page {:block/title "page1"}
+                 :blocks [{:block/title "block has pvalue with built-in tag"
+                           :build/properties
+                           {:p1 {:build/property-value :block
+                                 :block/title "t1"
+                                 :build/tags [:logseq.class/Task]}}}
+                          {:block/title "block has pvalue with user tag"
+                           :build/properties
+                           {:p1 {:build/property-value :block
+                                 :block/title "u1"
+                                 :build/tags [:C1]}}}
+                          {:block/title "Todo query",
+                           :build/tags [:logseq.class/Query],
+                           :build/properties
+                           {:logseq.property/query
+                            {:build/property-value :block
+                             :block/title "{:query (task Todo)}"
+                             :build/properties
+                             {:logseq.property.code/lang "clojure"
+                              :logseq.property.node/display-type :code}}}}]}]})]
     (is (= {:logseq.property.node/display-type :code
             :logseq.property.code/lang "clojure"}
            (-> (db-test/find-block-by-content @conn "{:query (task Todo)}")
+               db-test/readable-properties
+               (dissoc :logseq.property/created-from-property))))
+    (is (= {:block/tags [:logseq.class/Task]}
+           (-> (db-test/find-block-by-content @conn "t1")
+               db-test/readable-properties
+               (dissoc :logseq.property/created-from-property))))
+    (is (= {:block/tags [:user.class/C1]}
+           (-> (db-test/find-block-by-content @conn "u1")
                db-test/readable-properties
                (dissoc :logseq.property/created-from-property))))))

deps/db/test/logseq/db/sqlite/export_test.cljs

@@ -599,7 +599,13 @@
                        :block/title "{:query (task Todo)}"
                        :build/properties
                        {:logseq.property.code/lang "clojure"
-                        :logseq.property.node/display-type :code}}}}]}
+                        :logseq.property.node/display-type :code}}}}
+                    {:block/title "block has property value with tags and properties"
+                     :build/properties
+                     {:user.property/url
+                      {:build/property-value :block
+                       :block/title "https://example.com"
+                       :build/tags [:user.class/MyClass]}}}]}
           {:page {:block/title "page object"
                   :block/uuid page-object-uuid
                   :build/keep-uuid? true}