enhance: add import metadata

Useful for debugging different types of imports and knowing
when import was done, especially since it can differ from when
graph was created

deps/db/script/create_graph.cljs

@@ -27,7 +27,7 @@
                         [(node-path/join (os/homedir) "logseq" "graphs") graph-dir])
         sqlite-build-edn (merge {:auto-create-ontology? true}
                                 (-> (resolve-path edn-path) fs/readFileSync str edn/read-string))
-        conn (outliner-cli/init-conn dir db-name {:classpath (cp/get-classpath)})
+        conn (outliner-cli/init-conn dir db-name {:classpath (cp/get-classpath) :import-type :cli/create-graph})
         {:keys [init-tx block-props-tx]} (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 ...")

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

@@ -103,14 +103,17 @@
 (defn build-db-initial-data
   "Builds tx of initial data for a new graph including key values, initial files,
    built-in properties and built-in classes"
-  [config-content]
-  (let [initial-data [(sqlite-util/kv :logseq.kv/db-type "db")
-                      (sqlite-util/kv :logseq.kv/schema-version db-schema/version)
-                      (sqlite-util/kv :logseq.kv/graph-initial-schema-version db-schema/version)
-                      (sqlite-util/kv :logseq.kv/graph-created-at (common-util/time-ms))
-                      ;; Empty property value used by db.type/ref properties
-                      {:db/ident :logseq.property/empty-placeholder}
-                      {:db/ident :logseq.class/Root}]
+  [config-content & {:keys [import-type]}]
+  (let [initial-data (cond->
+                      [(sqlite-util/kv :logseq.kv/db-type "db")
+                       (sqlite-util/kv :logseq.kv/schema-version db-schema/version)
+                       (sqlite-util/kv :logseq.kv/graph-initial-schema-version db-schema/version)
+                       (sqlite-util/kv :logseq.kv/graph-created-at (common-util/time-ms))
+                       ;; Empty property value used by db.type/ref properties
+                       {:db/ident :logseq.property/empty-placeholder}
+                       {:db/ident :logseq.class/Root}]
+                       import-type
+                       (into (sqlite-util/import-tx import-type)))
         initial-files [{:block/uuid (d/squuid)
                         :file/path (str "logseq/" "config.edn")
                         :file/content config-content

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

@@ -136,3 +136,10 @@
   {:pre [(= "logseq.kv" (namespace k))]}
   {:db/ident k
    :kv/value value})
+
+(defn import-tx
+  "Creates tx for an import given an import-type"
+  [import-type]
+  [(kv :logseq.kv/import-type import-type)
+   ;; Timestamp is useful as this can occur much later than :logseq.kv/graph-created-at
+   (kv :logseq.kv/imported-at (common-util/time-ms))])

deps/outliner/src/logseq/outliner/cli.cljs

@@ -17,7 +17,8 @@
 
 (defn- setup-init-data
   "Setup initial data same as frontend.handler.repo/create-db"
-  [conn {:keys [additional-config classpath]}]
+  [conn {:keys [additional-config classpath import-type]
+         :or {import-type :cli/default}}]
   (let [config-content
         (cond-> (or (some-> (find-on-classpath classpath "templates/config.edn") fs/readFileSync str)
                     (do (println "Setting graph's config to empty since no templates/config.edn was found.")
@@ -27,7 +28,7 @@
           (string/replace-first #"(:file/name-format :triple-lowbar)"
                                 (str "$1 "
                                      (string/replace-first (str additional-config) #"^\{(.*)\}$" "$1"))))]
-    (d/transact! conn (sqlite-create-graph/build-db-initial-data config-content))))
+    (d/transact! conn (sqlite-create-graph/build-db-initial-data config-content {:import-type import-type}))))
 
 (defn init-conn
   "Create sqlite DB, initialize datascript connection and sync listener and then

src/main/frontend/handler/import.cljs

@@ -26,7 +26,8 @@
             [medley.core :as medley]
             [frontend.persist-db :as persist-db]
             [promesa.core :as p]
-            [frontend.db.async :as db-async]))
+            [frontend.db.async :as db-async]
+            [logseq.db.sqlite.util :as sqlite-util]))
 
 (defn index-files!
   "Create file structure, then parse into DB (client only)"
@@ -236,6 +237,7 @@
       (repo-handler/restore-and-setup-repo! graph)
       (state/set-current-repo! graph)
       (persist-db/<export-db graph {})
+      (db/transact! graph (sqlite-util/import-tx :sqlite-db))
       (finished-ok-handler))
      (p/catch
       (fn [e]

src/main/frontend/handler/repo.cljs

@@ -184,7 +184,9 @@
 (defn- create-db [full-graph-name {:keys [file-graph-import?]}]
   (->
    (p/let [config (migrate-db-config config/config-default-content)
-           _ (persist-db/<new full-graph-name {:config config})
+           _ (persist-db/<new full-graph-name
+                              (cond-> {:config config}
+                                file-graph-import? (assoc :import-type :file-graph)))
            _ (start-repo-db-if-not-exists! full-graph-name)
            _ (state/add-repo! {:url full-graph-name :root (config/get-local-dir full-graph-name)})
            _ (restore-and-setup-repo! full-graph-name)

src/main/frontend/worker/db_worker.cljs

@@ -278,7 +278,7 @@
       [db search-db client-ops-db])))
 
 (defn- create-or-open-db!
-  [repo {:keys [config]}]
+  [repo {:keys [config import-type]}]
   (when-not (worker-state/get-sqlite-conn repo)
     (p/let [[db search-db client-ops-db] (get-dbs repo)
             storage (new-sqlite-storage repo {})
@@ -302,7 +302,8 @@
         (swap! *client-ops-conns assoc repo client-ops-conn)
         (when (and db-based? (not initial-data-exists?))
           (let [config (or config {})
-                initial-data (sqlite-create-graph/build-db-initial-data config)]
+                initial-data (sqlite-create-graph/build-db-initial-data config
+                                                                        (when import-type {:import-type import-type}))]
             (d/transact! conn initial-data {:initial-db? true})))
 
         (try
@@ -429,12 +430,11 @@
 
   (createOrOpenDB
    [_this repo opts-str]
-   (let [{:keys [close-other-db? config]
-          :or {close-other-db? true}} (ldb/read-transit-str opts-str)]
+   (let [{:keys [close-other-db?] :or {close-other-db? true} :as opts} (ldb/read-transit-str opts-str)]
      (p/do!
       (when close-other-db?
         (close-other-dbs! repo))
-      (create-or-open-db! repo {:config config}))))
+      (create-or-open-db! repo (dissoc opts :close-other-db?)))))
 
   (getMaxTx
    [_this repo]