enhance: page export includes its properties and tags

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

@@ -11,6 +11,11 @@
 
 ;; Export fns
 ;; ==========
+(defn- ->build-tags [block-tags]
+  (->> (map :db/ident block-tags)
+       (remove #(= % :logseq.class/Page))
+       vec))
+
 (defn- buildable-property-value-entity
   "Converts property value to a buildable version"
   [property-ent pvalue]
@@ -18,9 +23,7 @@
         ;; Should page properties be pulled here?
         [:build/page (cond-> (select-keys pvalue [:block/title])
                        (seq (:block/tags pvalue))
-                       (assoc :build/tags (->> (map :db/ident (:block/tags pvalue))
-                                               (remove #(= % :logseq.class/Page))
-                                               vec)))]
+                       (assoc :build/tags (->build-tags (:block/tags pvalue))))]
         (ldb/journal? pvalue)
         [:build/page {:build/journal (:block/journal-day pvalue)}]
         :else
@@ -127,11 +130,11 @@
                                    (remove db-property/logseq-property?)
                                    (remove #(get properties %)))
         new-properties (build-export-properties db new-user-property-ids {})
+        build-tags (when (seq (:block/tags entity)) (->build-tags (:block/tags entity)))
         build-block (cond-> (select-keys entity
                                          (cond-> [:block/title] include-uuid? (conj :block/uuid)))
-                      (seq (:block/tags entity))
-                      (assoc :build/tags
-                             (mapv :db/ident (:block/tags entity)))
+                      (seq build-tags)
+                      (assoc :build/tags build-tags)
                       (seq ent-properties)
                       (assoc :build/properties
                              (buildable-properties db ent-properties (merge properties new-properties))))
@@ -211,15 +214,17 @@
                                    ;; Don't export pvalue-uuids of pvalue blocks as it's too excessive for now
                                    (merge (build-blocks-tree db (sort-by :block/order blocks) {:include-uuid? true})
                                           {:page (select-keys parent-page-ent [:block/title])})))))
+        page-ent-export (build-entity-export db page-entity {:properties properties})
+        page (merge (dissoc (:build/block page-ent-export) :block/title)
+                    (if (ldb/journal? page-entity)
+                      {:build/journal (:block/journal-day page-entity)}
+                      (select-keys page-entity [:block/title])))
         pages-and-blocks
-        (cond-> [{:page (if (ldb/journal? page-entity)
-                          {:build/journal (:block/journal-day page-entity)}
-                          (select-keys page-entity [:block/title]))
-                  :blocks blocks}]
+        (cond-> [{:page page :blocks blocks}]
           (seq pvalue-pages)
           (into (map #(select-keys % [:page :blocks]) pvalue-pages)))
-        properties' (apply merge properties (map :properties pvalue-pages))
-        classes' (apply merge classes (map :classes pvalue-pages))
+        properties' (apply merge properties (:properties page-ent-export) (map :properties pvalue-pages))
+        classes' (apply merge classes (:classes page-ent-export) (map :classes pvalue-pages))
         page-export
         (cond-> {:pages-and-blocks pages-and-blocks}
           (seq properties')

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

@@ -105,19 +105,15 @@
 
 ;; Tests a variety of blocks including block children with new properties, blocks with new classes
 ;; and blocks with built-in properties
-(deftest import-page-in-different-graph
+(deftest import-page-with-different-blocks
   (let [original-data
         {:properties {:user.property/default {:logseq.property/type :default
                                               :db/cardinality :db.cardinality/one
                                               :block/title "Default"}
-                      :user.property/p1 {:logseq.property/type :default
-                                         :db/cardinality :db.cardinality/one
-                                         :block/title "p1"}
                       :user.property/num {:logseq.property/type :number
                                           :db/cardinality :db.cardinality/one
                                           :block/title "num"}}
-         :classes {:user.class/MyClass {:block/title "My Class"
-                                        :build/class-properties [:user.property/default :user.property/p1]}}
+         :classes {:user.class/MyClass {:block/title "My Class"}}
          :pages-and-blocks
          [{:page {:block/title "page1"}
            :blocks [{:block/title "b1"
@@ -167,6 +163,38 @@
                        (fn [blocks] (into blocks blocks)))]
         (is (= expected-page-and-blocks (:pages-and-blocks full-imported-page)))))))
 
+(deftest import-page-with-different-page-and-classes
+  (let [original-data
+        {:properties {:user.property/p1 {:db/cardinality :db.cardinality/one, :logseq.property/type :default, :block/title "p1"}
+                      :user.property/p2 {:db/cardinality :db.cardinality/one, :logseq.property/type :default, :block/title "p2"}}
+         :classes {:user.class/MyClass {:block/title "My Class"
+                                        :build/class-properties [:user.property/p1 :user.property/p2]}}
+         :pages-and-blocks
+         [{:page {:block/title "page1"
+                  :build/properties {:user.property/p1 "woot"}
+                  :build/tags [:user.class/MyClass]}
+           :blocks []}]}
+        conn (db-test/create-conn-with-blocks original-data)
+        page (db-test/find-page-by-title @conn "page1")
+        conn2 (db-test/create-conn)
+        {:keys [init-tx block-props-tx] :as _txs}
+        (->> (sqlite-export/build-page-export @conn (:db/id page))
+             (sqlite-export/build-import @conn2 {}))
+        _ (assert (nil? (d/entity @conn2 :user.property/default)))
+        _ (assert (nil? (d/entity @conn2 :user.class/MyClass)))
+        _ (d/transact! conn2 init-tx)
+        _ (d/transact! conn2 block-props-tx)
+        ;; _ (cljs.pprint/pprint _txs)
+        page2 (db-test/find-page-by-title @conn2 "page1")
+        full-imported-page (sqlite-export/build-page-export @conn2 (:db/id page2))]
+
+    (is (= (:properties original-data) (:properties full-imported-page))
+        "Page's properties are imported")
+    (is (= (:classes original-data) (:classes full-imported-page))
+        "Page's classes are imported")
+    (is (= (:pages-and-blocks original-data) (:pages-and-blocks full-imported-page))
+        "Page's blocks are imported")))
+
 (deftest import-page-with-different-property-types
   (let [block-object-uuid (random-uuid)
         original-data