enhance: export+import supports properties

that double/overlap as classes

deps/db/script/create_graph.cljs

@@ -60,6 +60,7 @@
           (outliner-cli/build-blocks-tx sqlite-build-edn))]
     (println "Generating" (count (filter :block/name init-tx)) "pages and"
              (count (filter :block/title init-tx)) "blocks ...")
+    ;; (fs/writeFileSync "txs.edn" (with-out-str (cljs.pprint/pprint _txs)))
     ;; (cljs.pprint/pprint _txs)
     (d/transact! conn init-tx)
     (when (seq block-props-tx) (d/transact! conn block-props-tx))

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

@@ -378,7 +378,7 @@
 
 ;; TODO: How to detect these idents don't conflict with existing? :db/add?
 (defn- create-all-idents
-  [properties classes graph-namespace]
+  [properties classes {:keys [graph-namespace build-existing-tx?]}]
   (let [property-idents (->> (keys properties)
                              (map #(vector %
                                            (if graph-namespace
@@ -396,8 +396,9 @@
                           (into {}))
         _ (assert (= (count (set (vals class-idents))) (count classes)) "All class db-idents must be unique")
         all-idents (merge property-idents class-idents)]
-    (assert (= (count all-idents) (+ (count property-idents) (count class-idents)))
-            "Class and property db-idents have no overlap")
+    (when-not build-existing-tx?
+      (assert (= (count all-idents) (+ (count property-idents) (count class-idents)))
+              "Class and property db-idents are unique and do not overlap"))
     all-idents))
 
 (defn- build-page-tx [page all-idents page-uuids properties options]
@@ -635,7 +636,7 @@
   (let [pages-and-blocks' (pre-build-pages-and-blocks pages-and-blocks properties (dissoc options :pages-and-blocks :properties))
         page-uuids (create-page-uuids pages-and-blocks')
         {:keys [classes properties]} (if auto-create-ontology? (auto-create-ontology options) options)
-        all-idents (create-all-idents properties classes graph-namespace)
+        all-idents (create-all-idents properties classes options)
         properties-tx (build-properties-tx properties page-uuids all-idents options)
         classes-tx (build-classes-tx classes properties page-uuids all-idents options)
         class-ident->id (->> classes-tx (map (juxt :db/ident :db/id)) (into {}))

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

@@ -116,6 +116,8 @@
       (->> properties-config-by-ent
            (map (fn [[ent build-property]]
                   (let [ent-properties (apply dissoc (db-property/properties ent)
+                                              ;; For overlapping class properties, these would be built in :classes
+                                              :logseq.property/parent :logseq.property.class/properties
                                               (into db-property/schema-properties db-property/public-db-attribute-properties))]
                     [(:db/ident ent)
                      (cond-> build-property
@@ -508,7 +510,7 @@
                                 (seq ent-properties)
                                 (assoc :build/properties
                                        (-> (buildable-properties db ent-properties properties options)
-                                           (dissoc :logseq.property.class/properties))))))))
+                                           (dissoc :logseq.property/classes :logseq.property.class/properties))))))))
              (into {}))]
     (cond-> {}
       (seq properties)

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

@@ -728,3 +728,22 @@
     (is (= (sort-pages-and-blocks (:pages-and-blocks original-data)) (:pages-and-blocks imported-graph)))
     (is (= (::sqlite-export/graph-files original-data) (::sqlite-export/graph-files imported-graph))
         "All :file/path entities are imported")))
+
+(deftest import-graph-overlapping-ontology-properties
+  (let [original-data
+        {:properties {:user.property/p1
+                      {:logseq.property/type :node
+                       :build/property-classes [:user.property/p1]}
+                      :user.property/p2 {:logseq.property/type :default}}
+         :classes {:user.class/C1 {}
+                   :user.property/p1
+                   {:build/class-parent :user.class/C1
+                    :build/class-properties [:user.property/p2]}}
+         :build-existing-tx? true}
+        conn (db-test/create-conn-with-blocks original-data)
+        conn2 (db-test/create-conn)
+        imported-graph (export-graph-and-import-to-another-graph conn conn2 {})]
+    (is (= (expand-properties (:properties original-data)) (:properties imported-graph)))
+    (is (= (expand-classes (:classes original-data))
+           (-> (:classes imported-graph)
+               (medley/dissoc-in [:user.property/p1 :build/properties]))))))