enhance: creating built-in properties when creating db conn

deps/db/src/logseq/db.cljs

@@ -4,7 +4,11 @@
             [logseq.db.frontend.schema :as db-schema]
             [datascript.core :as d]
             [cljs-time.core :as t]
-            [cljs-time.coerce :as tc]))
+            [cljs-time.coerce :as tc]
+            [logseq.db.frontend.property :as db-property]
+            [logseq.db.frontend.property.util :as db-property-util]
+            [logseq.db.sqlite.util :as sqlite-util]
+            [clojure.string :as string]))
 
 (defn create-default-pages!
   "Creates default pages if one of the default pages does not exist. This
@@ -22,12 +26,34 @@
                           default-db/built-in-pages)]
       (d/transact! db-conn built-in-pages))))
 
+(defn create-built-in-properties!
+  [conn]
+  (let [txs (mapcat
+             (fn [[k-keyword {:keys [schema original-name] :as property-config}]]
+               (let [k-name (name k-keyword)]
+                 (if (:closed-values property-config)
+                   (db-property-util/build-closed-values
+                    (or original-name k-name)
+                    (assoc property-config :block/uuid (d/squuid))
+                    {})
+                   [(sqlite-util/build-new-property
+                     {:block/schema schema
+                      :block/original-name (or original-name k-name)
+                      :block/name (string/lower-case k-name)
+                      :block/uuid (d/squuid)})])))
+             db-property/built-in-properties)]
+    (when (seq txs)
+      (d/transact! conn txs))))
+
 (defn start-conn
   "Create datascript conn with schema and default data"
   [& {:keys [create-default-pages? schema]
       :or {create-default-pages? true
            schema db-schema/schema}}]
-  (let [db-conn (d/create-conn schema)]
+  (let [db-conn (d/create-conn schema)
+        db-based? (= schema db-schema/schema)]
     (when create-default-pages?
       (create-default-pages! db-conn {}))
+    (when db-based?
+      (create-built-in-properties! db-conn))
     db-conn))

src/main/frontend/db/conn.cljs

@@ -81,6 +81,18 @@
    :db/ident key
    key value})
 
+(defn transact!
+  ([repo tx-data]
+   (transact! repo tx-data nil))
+  ([repo tx-data tx-meta]
+   (when-let [conn (get-db repo false)]
+     ;; (prn :debug "DB transact:")
+     ;; (frontend.util/pprint {:tx-data tx-data
+     ;;                        :tx-meta tx-meta})
+     (if tx-meta
+       (d/transact! conn (vec tx-data) tx-meta)
+       (d/transact! conn (vec tx-data))))))
+
 (defn start!
   ([repo]
    (start! repo {}))
@@ -91,8 +103,8 @@
      (when listen-handler
        (listen-handler repo))
      (when db-graph?
-       (d/transact! db-conn [(kv :db/type "db")])
-       (d/transact! db-conn [(kv :schema/version db-schema/version)]))
+       (transact! db-name [(kv :db/type "db")])
+       (transact! db-name [(kv :schema/version db-schema/version)]))
      (ldb/create-default-pages! db-conn {:db-graph? db-graph?}))))
 
 (defn destroy-all!

src/main/frontend/db/restore.cljs

@@ -1,17 +1,11 @@
 (ns frontend.db.restore
   "Fns for DB restore(from text or sqlite)"
-  (:require [datascript.core :as d]
-            [frontend.config :as config]
-            [frontend.db.conn :as db-conn]
+  (:require [frontend.db.conn :as db-conn]
             [frontend.db.react :as react]
             [frontend.state :as state]
             [frontend.persist-db :as persist-db]
-            [logseq.db.sqlite.util :as sqlite-util]
             [promesa.core :as p]
-            [frontend.util :as util]
             [cljs-time.core :as t]
-            [logseq.db.frontend.property :as db-property]
-            [logseq.db.frontend.property.util :as db-property-util]
             [datascript.transit :as dt]
             [logseq.db.sqlite.common-db :as sqlite-common-db]))
 
@@ -34,40 +28,6 @@
         :else
         true))))
 
-(defn- update-built-in-properties!
-  [conn]
-  (let [txs (mapcat
-             (fn [[k-keyword {:keys [schema original-name] :as property-config}]]
-               (let [k-name (name k-keyword)
-                     property (d/entity @conn [:block/name k-name])]
-                 (when (and
-                        (not= {:schema schema
-                               :original-name (or original-name k-name)}
-                              {:schema (:block/schema property)
-                               :original-name (:block/original-name property)})
-                         ;; Updating closed values disabled until it's worth the effort
-                         ;; to diff closed values
-                        (not (:closed-values property-config)))
-                   (if property
-                     [{:block/schema schema
-                       :block/original-name (or original-name k-name)
-                       :block/name (util/page-name-sanity-lc k-name)
-                       :block/uuid (:block/uuid property)
-                       :block/type "property"}]
-                     (if (:closed-values property-config)
-                       (db-property-util/build-closed-values
-                        (or original-name k-name)
-                        (assoc property-config :block/uuid (d/squuid))
-                        {})
-                       [(sqlite-util/build-new-property
-                         {:block/schema schema
-                          :block/original-name (or original-name k-name)
-                          :block/name (util/page-name-sanity-lc k-name)
-                          :block/uuid (d/squuid)})])))))
-             db-property/built-in-properties)]
-    (when (seq txs)
-      (d/transact! conn txs))))
-
 (defn restore-graph!
   "Restore db from SQLite"
   [repo]
@@ -81,11 +41,7 @@
           conn (sqlite-common-db/restore-initial-data datoms db-schema)
           db-name (db-conn/datascript-db repo)
           _ (swap! db-conn/conns assoc db-name conn)
-          end-time (t/now)
-          db-based? (config/db-based-graph? repo)]
-
-    ;; FIXME: why not do this when creating the db?
-    (when db-based? (update-built-in-properties! conn))
+          end-time (t/now)]
 
     (println :restore-graph-from-sqlite!-prepare (t/in-millis (t/interval start-time end-time)) "ms"
              " Datoms in total: " datoms-count)

src/main/frontend/db/utils.cljs

@@ -121,13 +121,7 @@
   [repo-url tx-data tx-meta]
   (let [tx-data (gp-util/fast-remove-nils tx-data)]
     (when (seq tx-data)
-      ;; (prn :debug "DB transact:")
-      ;; (frontend.util/pprint {:tx-data tx-data
-      ;;                        :tx-meta tx-meta})
-      (when-let [conn (conn/get-db repo-url false)]
-        (if tx-meta
-          (d/transact! conn (vec tx-data) tx-meta)
-          (d/transact! conn (vec tx-data)))))))
+      (conn/transact! repo-url tx-data tx-meta))))
 
 (if config/publishing?
   (defn- transact!*