fix: multiple bugs with built-in pages, fixes LOG-3046

- file graph wasn't creating built in pages
- 3 places where db graphs were incorrectly using file graph built in
  page names
- file graphs creating default pages with incorrect format

.clj-kondo/config.edn

@@ -148,6 +148,7 @@
              logseq.db.sqlite.util sqlite-util
              logseq.graph-parser graph-parser
              logseq.graph-parser.text text
+             logseq.graph-parser.db gp-db
              logseq.graph-parser.block gp-block
              logseq.graph-parser.mldoc gp-mldoc
              logseq.graph-parser.property gp-property

deps/db/src/logseq/db.cljs

@@ -1,8 +1,7 @@
 (ns logseq.db
-  "Main namespace for public db fns"
-  (:require [logseq.db.frontend.default :as default-db]
-            [logseq.db.frontend.schema :as db-schema]
-            [datascript.core :as d]
+  "Main namespace for public db fns. For DB and file graphs.
+   For shared file graph only fns, use logseq.graph-parser.db"
+  (:require [datascript.core :as d]
             [clojure.string :as string]
             [logseq.common.util :as common-util]
             [logseq.common.config :as common-config]
@@ -67,39 +66,6 @@
        (let [f (or @*transact-fn d/transact!)]
          (f repo-or-conn tx-data tx-meta))))))
 
-(defn build-pages-tx
-  [pages]
-  (let [time (common-util/time-ms)]
-    (map
-     (fn [m]
-       (-> m
-           (assoc :block/created-at time)
-           (assoc :block/updated-at time)
-           (assoc :block/format :markdown)))
-      pages)))
-
-(defn build-default-pages-tx
-  []
-  (build-pages-tx default-db/built-in-pages))
-
-(defn create-default-pages!
-  "Creates default pages if one of the default pages does not exist. This
-   fn is idempotent"
-  [db-conn _opts]
-  (when-not (d/entity @db-conn [:block/name "card"])
-    (let [built-in-pages (build-default-pages-tx)]
-      (transact! db-conn built-in-pages))))
-
-(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)]
-    (when create-default-pages?
-      (create-default-pages! db-conn {}))
-    db-conn))
-
 (defn sort-by-left
   [blocks parent]
   (let [left->blocks (->> (reduce (fn [acc b] (assoc! acc (:db/id (:block/left b)) b))
@@ -236,11 +202,12 @@
     (nil? (:block/_left page))))
 
 (defn get-orphaned-pages
-  [db {:keys [pages empty-ref-f]
-       :or {empty-ref-f (fn [page] (zero? (count (:block/_refs page))))}}]
+  [db {:keys [pages empty-ref-f built-in-pages-names]
+       :or {empty-ref-f (fn [page] (zero? (count (:block/_refs page))))
+            built-in-pages-names #{}}}]
   (let [pages (->> (or pages (get-pages db))
                    (remove nil?))
-        built-in-pages (set (map string/lower-case default-db/built-in-pages-names))
+        built-in-pages (set (map string/lower-case built-in-pages-names))
         orphaned-pages (->>
                         (map
                          (fn [page]

deps/db/src/logseq/db/frontend/default.cljs

@@ -1,30 +1,6 @@
 (ns logseq.db.frontend.default
   "Provides vars and fns for dealing with default/built-in? data"
-  (:require [clojure.string :as string]
-            [clojure.set :as set]
-            [datascript.core :as d]))
-
-(defonce built-in-markers
-  ["NOW" "LATER" "DOING" "DONE" "CANCELED" "CANCELLED" "IN-PROGRESS" "TODO" "WAIT" "WAITING"])
-
-(defonce built-in-priorities
-  ["A" "B" "C"])
-
-(defonce built-in-pages-names
-  (set/union
-   (set built-in-markers)
-   (set built-in-priorities)
-   #{"Favorites" "Contents" "card"}))
-
-(defn page-title->block
-  [title]
-  {:block/name (string/lower-case title)
-   :block/original-name title
-   :block/journal? false
-   :block/uuid (random-uuid)})
-
-(def built-in-pages
-  (mapv page-title->block built-in-pages-names))
+  (:require [datascript.core :as d]))
 
 (defn mark-block-as-built-in
   "Marks built-in blocks as built-in? including pages, classes, properties and closed values"

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

@@ -1,7 +1,6 @@
 (ns logseq.db.frontend.property.util
   "Util fns for building core property concepts"
   (:require [logseq.db.sqlite.util :as sqlite-util]
-            [logseq.common.util :as common-util]
             [logseq.db.frontend.default :as default-db]
             [datascript.core :as d]))
 
@@ -38,20 +37,11 @@
     true
     sqlite-util/block-with-timestamps))
 
-(defn- build-new-page
-  "Builds a basic page to be transacted. A minimal version of gp-block/page-name->map"
-  [page-name]
-  (sqlite-util/block-with-timestamps
-   {:block/name (common-util/page-name-sanity-lc page-name)
-    :block/original-name page-name
-    :block/journal? false
-    :block/uuid (d/squuid)}))
-
 (defn build-property-hidden-page
   "Builds a hidden property page for closed values to be transacted"
   [property]
   (let [page-name (str hidden-page-name-prefix (:block/uuid property))]
-    (-> (build-new-page page-name)
+    (-> (sqlite-util/build-new-page page-name)
         (assoc :block/type #{"hidden"}
                :block/format :markdown))))
 

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

@@ -7,7 +7,6 @@
             [logseq.db.frontend.property.util :as db-property-util]
             [logseq.common.util :as common-util]
             [datascript.core :as d]
-            [logseq.db :as ldb]
             [logseq.db.frontend.default :as default-db]))
 
 (defn- build-initial-properties
@@ -44,6 +43,9 @@
   {:db/ident (keyword "logseq.kv" (str (namespace key) "-" (name key)))
    key value})
 
+(def built-in-pages-names
+  #{"Contents"})
+
 (defn build-db-initial-data
   [db* config-content]
   (let [db (d/db-with db*
@@ -65,7 +67,8 @@
                         :file/path (str "logseq/" "custom.js")
                         :file/content ""
                         :file/last-modified-at (js/Date.)}]
-        default-pages (->> (ldb/build-pages-tx (map default-db/page-title->block ["Contents"]))
+        default-pages (->> (map sqlite-util/build-new-page built-in-pages-names)
+                           (map #(assoc % :block/format :markdown))
                            (map #(default-db/mark-block-as-built-in db %)))
         default-properties (build-initial-properties db)
         db-ident->properties (zipmap

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

@@ -6,6 +6,7 @@
             [cognitect.transit :as transit]
             [datascript.transit :as dt]
             [datascript.impl.entity :as de]
+            [datascript.core :as d]
             [cljs-bean.transit]))
 
 (defonce db-version-prefix "logseq_db_")
@@ -87,3 +88,12 @@
            :block/journal? false
            :block/format :markdown}
           block)))
+
+(defn build-new-page
+  "Builds a basic page to be transacted. A minimal version of gp-block/page-name->map"
+  [page-name]
+  (block-with-timestamps
+   {:block/name (common-util/page-name-sanity-lc page-name)
+    :block/original-name page-name
+    :block/journal? false
+    :block/uuid (d/squuid)}))

deps/graph-parser/src/logseq/graph_parser/cli.cljs

@@ -7,7 +7,7 @@
             [logseq.common.config :as common-config]
             [logseq.graph-parser :as graph-parser]
             [logseq.common.util :as common-util]
-            [logseq.db :as ldb]))
+            [logseq.graph-parser.db :as gp-db]))
 
 (defn- slurp
   "Return file contents like clojure.core/slurp"
@@ -74,7 +74,7 @@
   ([dir options]
    (let [config (read-config dir)
          files (or (:files options) (build-graph-files dir config))
-         conn (or (:conn options) (ldb/start-conn))
+         conn (or (:conn options) (gp-db/start-conn))
          _ (when-not (:files options) (println "Parsing" (count files) "files..."))
          asts (parse-files conn files (merge options {:config config}))]
      {:conn conn

deps/graph-parser/src/logseq/graph_parser/db.cljs

@@ -0,0 +1,55 @@
+(ns logseq.graph-parser.db
+  "File graph specific db fns"
+  (:require [datascript.core :as d]
+            [clojure.set :as set]
+            [clojure.string :as string]
+            [logseq.common.util :as common-util]
+            [logseq.db.frontend.schema :as db-schema]
+            [logseq.db :as ldb]))
+
+(defonce built-in-markers
+  ["NOW" "LATER" "DOING" "DONE" "CANCELED" "CANCELLED" "IN-PROGRESS" "TODO" "WAIT" "WAITING"])
+
+(defonce built-in-priorities
+  ["A" "B" "C"])
+
+(defonce built-in-pages-names
+  (set/union
+   (set built-in-markers)
+   (set built-in-priorities)
+   #{"Favorites" "Contents" "card"}))
+
+(defn- page-title->block
+  [title]
+  {:block/name (string/lower-case title)
+   :block/original-name title
+   :block/journal? false
+   :block/uuid (random-uuid)})
+
+(def built-in-pages
+  (mapv page-title->block built-in-pages-names))
+
+(defn- build-pages-tx
+  [pages]
+  (let [time (common-util/time-ms)]
+    (map
+     (fn [m]
+       (-> m
+           (assoc :block/created-at time)
+           (assoc :block/updated-at time)))
+     pages)))
+
+(defn create-default-pages!
+  "Creates default pages if one of the default pages does not exist. This
+   fn is idempotent"
+  [db-conn]
+  (when-not (d/entity @db-conn [:block/name "card"])
+    (let [built-in-pages (build-pages-tx built-in-pages)]
+      (ldb/transact! db-conn built-in-pages))))
+
+(defn start-conn
+  "Create datascript conn with schema and default data"
+  []
+  (let [db-conn (d/create-conn db-schema/schema)]
+    (create-default-pages! db-conn)
+    db-conn))

deps/graph-parser/src/logseq/graph_parser/test/docs_graph_helper.cljs

@@ -106,7 +106,7 @@
                 (into {})))
         "Task marker counts")
 
-    (is (= {:markdown 6113 :org 509} (get-block-format-counts db))
+    (is (= {:markdown 6106 :org 509} (get-block-format-counts db))
         "Block format counts")
 
     (is (= {:description 81, :updated-at 46, :tags 5, :logseq.macro-arguments 104
@@ -161,7 +161,7 @@
   ;; only increase over time as the docs graph rarely has deletions
   (testing "Counts"
     (is (= 303 (count files)) "Correct file count")
-    (is (= 64382 (count (d/datoms db :eavt))) "Correct datoms count")
+    (is (= 64375 (count (d/datoms db :eavt))) "Correct datoms count")
 
     (is (= 5866
            (ffirst

deps/graph-parser/test/logseq/graph_parser/block_test.cljs

@@ -2,7 +2,7 @@
   (:require [logseq.graph-parser.block :as gp-block]
             [logseq.graph-parser.mldoc :as gp-mldoc]
             [logseq.graph-parser :as graph-parser]
-            [logseq.db :as ldb]
+            [logseq.graph-parser.db :as gp-db]
             [logseq.common.util.block-ref :as block-ref]
             [datascript.core :as d]
             [cljs.test :refer [deftest are testing is]]))
@@ -121,7 +121,7 @@
        first))
 
 (deftest refs-from-block-refs
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         id "63f528da-284a-45d1-ac9c-5d6a7435f6b4"
         block (str "A block\nid:: " id)
         block-ref-via-content (str "Link to " (block-ref/->block-ref id))
@@ -148,7 +148,7 @@
             "Block that links to a block via page properties has correct block ref")))))
 
 (deftest timestamp-blocks
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         deadline-block "do something\nDEADLINE: <2023-02-21 Tue>"
         scheduled-block "do something else\nSCHEDULED: <2023-02-20 Mon>"
         body (str "- " deadline-block "\n- " scheduled-block)]

deps/graph-parser/test/logseq/graph_parser/cli_test.cljs

@@ -5,7 +5,7 @@
             [clojure.string :as string]
             [datascript.core :as d]
             [logseq.db.sqlite.db :as sqlite-db]
-            [logseq.db :as ldb]
+            [logseq.graph-parser.db :as gp-db]
             [clojure.set :as set]
             ["fs" :as fs]
             ["process" :as process]
@@ -129,7 +129,7 @@
   (let [conn (sqlite-db/open-db! dir db-name)
         frontend-blocks (create-frontend-blocks pages-to-blocks)
         _ (d/transact! conn frontend-blocks)]
-    (ldb/create-default-pages! conn {:db-graph? true})
+    (gp-db/create-default-pages! conn)
     @conn))
 
 (defn- datoms->entity-maps

deps/graph-parser/test/logseq/graph_parser_test.cljs

@@ -2,8 +2,7 @@
   (:require [cljs.test :refer [deftest testing is are]]
             [clojure.string :as string]
             [logseq.graph-parser :as graph-parser]
-            [logseq.db :as ldb]
-            [logseq.db.frontend.default :as default-db]
+            [logseq.graph-parser.db :as gp-db]
             [logseq.graph-parser.block :as gp-block]
             [logseq.graph-parser.property :as gp-property]
             [datascript.core :as d]))
@@ -56,7 +55,7 @@
 
 (deftest parse-file
   (testing "id properties"
-    (let [conn (ldb/start-conn)]
+    (let [conn (gp-db/start-conn)]
       (graph-parser/parse-file conn "foo.md" "- id:: 628953c1-8d75-49fe-a648-f4c612109098" {})
       (is (= [{:id "628953c1-8d75-49fe-a648-f4c612109098"}]
              (->> (d/q '[:find (pull ?b [*])
@@ -68,7 +67,7 @@
           "id as text has correct :block/properties")))
 
   (testing "unexpected failure during block extraction"
-    (let [conn (ldb/start-conn)
+    (let [conn (gp-db/start-conn)
           deleted-page (atom nil)]
       (with-redefs [gp-block/with-pre-block-if-exists (fn stub-failure [& _args]
                                                         (throw (js/Error "Testing unexpected failure")))]
@@ -81,7 +80,7 @@
           "Page should not be deleted when there is unexpected failure")))
 
   (testing "parsing whiteboard page"
-    (let [conn (ldb/start-conn)]
+    (let [conn (gp-db/start-conn)]
       (graph-parser/parse-file conn "/whiteboards/foo.edn" (pr-str foo-edn) {})
       (let [blocks (d/q '[:find (pull ?b [* {:block/page
                                              [:block/name
@@ -101,7 +100,7 @@
             "parsed block in the whiteboard page has correct parent page"))))
 
   (testing "Loading whiteboard pages that same block/uuid should throw an error."
-    (let [conn (ldb/start-conn)]
+    (let [conn (gp-db/start-conn)]
       (graph-parser/parse-file conn "/whiteboards/foo.edn" (pr-str foo-edn) {})
       (is (thrown-with-msg?
            js/Error
@@ -109,7 +108,7 @@
            (graph-parser/parse-file conn "/whiteboards/foo-conflict.edn" (pr-str foo-conflict-edn) {})))))
 
   (testing "Loading whiteboard pages should ignore the :block/name property inside :block/parent."
-    (let [conn (ldb/start-conn)]
+    (let [conn (gp-db/start-conn)]
       (graph-parser/parse-file conn "/whiteboards/foo.edn" (pr-str foo-edn) {})
       (graph-parser/parse-file conn "/whiteboards/bar.edn" (pr-str bar-edn) {})
       (let [pages (d/q '[:find ?name
@@ -121,7 +120,7 @@
         (is (= pages #{["foo"] ["bar"]}))))))
 
 (defn- test-property-order [num-properties]
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         properties (mapv #(keyword (str "p" %)) (range 0 num-properties))
         text (->> properties
                   (map #(str (name %) ":: " (name %) "-value"))
@@ -147,7 +146,7 @@
     (test-property-order 10)))
 
 (deftest quoted-property-values
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         _ (graph-parser/parse-file conn
                                    "foo.md"
                                    "- desc:: \"#foo is not a ref\""
@@ -166,7 +165,7 @@
         "No refs from property value")))
 
 (deftest non-string-property-values
-  (let [conn (ldb/start-conn)]
+  (let [conn (gp-db/start-conn)]
     (graph-parser/parse-file conn
                              "lythe-of-heaven.md"
                              "rating:: 8\nrecommend:: true\narchive:: false"
@@ -180,7 +179,7 @@
                 first)))))
 
 (deftest linkable-built-in-properties
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         _ (graph-parser/parse-file conn
                                    "lol.md"
                                    (str "alias:: 233\ntags:: fun, facts"
@@ -219,7 +218,7 @@
   "Runs tests on page properties and block properties. file-properties is what is
   visible in a file and db-properties is what is pulled out from the db"
   [file-properties db-properties user-config]
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         page-content (gp-property/->block-content file-properties)
         ;; Create Block properties from given page ones
         block-property-transform (fn [m] (update-keys m #(keyword (str "block-" (name %)))))
@@ -292,7 +291,7 @@
      {})))
 
 (deftest invalid-properties
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         properties {"foo" "valid"
                     "[[foo]]" "invalid"
                     "some,prop" "invalid"
@@ -326,8 +325,8 @@
 
 (deftest correct-page-names-created-from-title
   (testing "from title"
-    (let [conn (ldb/start-conn)
-          built-in-pages (set (map string/lower-case default-db/built-in-pages-names))]
+    (let [conn (gp-db/start-conn)
+          built-in-pages (set (map string/lower-case gp-db/built-in-pages-names))]
       (graph-parser/parse-file conn
                                "foo.md"
                                "title:: core.async"
@@ -342,8 +341,8 @@
                   set)))))
 
   (testing "from cased org title"
-    (let [conn (ldb/start-conn)
-          built-in-pages (set default-db/built-in-pages-names)]
+    (let [conn (gp-db/start-conn)
+          built-in-pages (set gp-db/built-in-pages-names)]
       (graph-parser/parse-file conn
                                "foo.org"
                                ":PROPERTIES:
@@ -362,8 +361,8 @@
 
 (deftest correct-page-names-created-from-page-refs
   (testing "for file, mailto, web and other uris in markdown"
-    (let [conn (ldb/start-conn)
-          built-in-pages (set (map string/lower-case default-db/built-in-pages-names))]
+    (let [conn (gp-db/start-conn)
+          built-in-pages (set (map string/lower-case gp-db/built-in-pages-names))]
       (graph-parser/parse-file conn
                                "foo.md"
                                (str "- [title]([[bar]])\n"
@@ -384,8 +383,8 @@
                   set)))))
 
 (testing "for web and page uris in org"
-    (let [conn (ldb/start-conn)
-          built-in-pages (set (map string/lower-case default-db/built-in-pages-names))]
+    (let [conn (gp-db/start-conn)
+          built-in-pages (set (map string/lower-case gp-db/built-in-pages-names))]
       (graph-parser/parse-file conn
                                "foo.org"
                                (str "* [[bar][title]]\n"
@@ -403,7 +402,7 @@
 
 (deftest duplicated-ids
   (testing "duplicated block ids in same file"
-    (let [conn (ldb/start-conn)
+    (let [conn (gp-db/start-conn)
           extract-block-ids (atom #{})
           parse-opts {:extract-options {:extract-block-ids extract-block-ids}}
           block-id #uuid "63f199bc-c737-459f-983d-84acfcda14fe"]
@@ -420,7 +419,7 @@ id:: 63f199bc-c737-459f-983d-84acfcda14fe
         (is (= 1 (count (filter #(= (:block/uuid %) block-id) blocks)))))))
 
   (testing "duplicated block ids in multiple files"
-    (let [conn (ldb/start-conn)
+    (let [conn (gp-db/start-conn)
           extract-block-ids (atom #{})
           parse-opts {:extract-options {:extract-block-ids extract-block-ids}}
           block-id #uuid "63f199bc-c737-459f-983d-84acfcda14fe"]

deps/outliner/src/logseq/outliner/core.cljs

@@ -14,11 +14,13 @@
             [logseq.db :as ldb]
             [logseq.graph-parser.block :as gp-block]
             [logseq.graph-parser.property :as gp-property]
+            [logseq.graph-parser.db :as gp-db]
             [logseq.db.frontend.property :as db-property]
             [logseq.db.sqlite.util :as sqlite-util]
             [cljs.pprint :as pprint]
             [logseq.common.marker :as common-marker]
-            [logseq.db.frontend.content :as db-content]))
+            [logseq.db.frontend.content :as db-content]
+            [logseq.db.sqlite.create-graph :as sqlite-create-graph]))
 
 (def ^:private block-map
   (mu/optional-keys
@@ -110,6 +112,10 @@
                            (remove nil?))
             orphaned-pages (when (seq old-pages)
                              (ldb/get-orphaned-pages db {:pages old-pages
+                                                         :built-in-pages-names
+                                                         (if db-graph?
+                                                           sqlite-create-graph/built-in-pages-names
+                                                           gp-db/built-in-pages-names)
                                                          :empty-ref-f (fn [page]
                                                                         (let [refs (:block/_refs page)]
                                                                           (and (or (zero? (count refs))

deps/publishing/test/logseq/publishing/db_test.cljs

@@ -4,10 +4,10 @@
             [logseq.publishing.db :as publish-db]
             [logseq.graph-parser :as graph-parser]
             [datascript.core :as d]
-            [logseq.db :as ldb]))
+            [logseq.graph-parser.db :as gp-db]))
 
 (deftest clean-export!
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         _ (graph-parser/parse-file conn "page1.md" "public:: false\n- b11\n- b12\n- ![awesome.png](../assets/awesome_1648822509908_0.png)")
         _ (graph-parser/parse-file conn "page2.md" "- b21\n- ![thumb-on-fire.PNG](../assets/thumb-on-fire_1648822523866_0.PNG)")
         _ (graph-parser/parse-file conn "page3.md" "- b31")
@@ -34,7 +34,7 @@
         "Only exports assets from public pages")))
 
 (deftest filter-only-public-pages-and-blocks
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         _ (graph-parser/parse-file conn "page1.md" "- b11\n- b12\n- ![awesome.png](../assets/awesome_1648822509908_0.png)")
         _ (graph-parser/parse-file conn "page2.md" "alias:: page2-alias\npublic:: true\n- b21\n- ![thumb-on-fire.PNG](../assets/thumb-on-fire_1648822523866_0.PNG)")
         _ (graph-parser/parse-file conn "page3.md" "public:: true\n- b31")

src/main/frontend/components/query/builder.cljs

@@ -13,7 +13,7 @@
             [frontend.util :as util]
             [frontend.search :as search]
             [frontend.mixins :as mixins]
-            [logseq.db.frontend.default :as db-default]
+            [logseq.graph-parser.db :as gp-db]
             [rum.core :as rum]
             [clojure.string :as string]
             [logseq.common.util :as common-util]
@@ -182,7 +182,7 @@
                  (append-tree! *tree opts loc [:sample (util/safe-parse-int value)])))
 
        "task"
-       (select db-default/built-in-markers
+       (select gp-db/built-in-markers
                (fn [value]
                  (when (seq value)
                    (append-tree! *tree opts loc (vec (cons :task value)))))
@@ -195,7 +195,7 @@
                 :on-apply (:toggle-fn opts)})
 
        "priority"
-       (select db-default/built-in-priorities
+       (select gp-db/built-in-priorities
                (fn [value]
                  (when (seq value)
                    (append-tree! *tree opts loc (vec (cons :priority value)))))

src/main/frontend/db.cljs

@@ -8,7 +8,6 @@
             [frontend.db.transact :as db-transact]
             [frontend.db.utils]
             [frontend.namespaces :refer [import-vars]]
-            [logseq.db.frontend.default :as default-db]
             [logseq.db :as ldb]))
 
 (import-vars
@@ -53,9 +52,7 @@
   custom-query]
 
  [frontend.db.query-react
-  react-query custom-query-result-transform]
-
- [logseq.db.frontend.default built-in-pages-names built-in-pages page-title->block])
+  react-query custom-query-result-transform])
 
 (defn start-db-conn!
   ([repo]

src/main/frontend/db/conn.cljs

@@ -7,9 +7,11 @@
             [frontend.config :as config]
             [frontend.util.text :as text-util]
             [logseq.graph-parser.text :as text]
+            [logseq.graph-parser.db :as gp-db]
+            [datascript.core :as d]
             [logseq.db :as ldb]
             [logseq.common.util :as common-util]
-            [logseq.db.sqlite.util :as sqlite-util]))
+            [logseq.db.frontend.schema :as db-schema]))
 
 (defonce conns (atom {}))
 
@@ -53,8 +55,6 @@
       (str (if (util/electron?) "" config/idb-db-prefix)
            path))))
 
-(def get-schema sqlite-util/get-schema)
-
 (defn get-db
   ([]
    (get-db (state/get-current-repo) true))
@@ -94,11 +94,11 @@
 (defn start!
   ([repo]
    (start! repo {}))
-  ([repo {:keys [listen-handler create-default-pages?]
-          :or {create-default-pages? false}}]
+  ([repo {:keys [listen-handler]}]
    (let [db-name (datascript-db repo)
-         db-conn (ldb/start-conn :schema (get-schema repo)
-                                 :create-default-pages? create-default-pages?)]
+         db-conn (if (config/db-based-graph? repo)
+                   (d/create-conn db-schema/schema-for-db-based-graph)
+                   (gp-db/start-conn))]
      (swap! conns assoc db-name db-conn)
      (when listen-handler
        (listen-handler repo)))))

src/main/frontend/db/model.cljs

@@ -14,7 +14,9 @@
             [frontend.util :as util :refer [react]]
             [logseq.db.frontend.rules :as rules]
             [logseq.db.frontend.content :as db-content]
+            [logseq.db.sqlite.create-graph :as sqlite-create-graph]
             [logseq.graph-parser.text :as text]
+            [logseq.graph-parser.db :as gp-db]
             [logseq.common.util :as common-util]
             [logseq.common.util.date-time :as date-time-util]
             [frontend.config :as config]
@@ -935,7 +937,12 @@ independent of format as format specific heading characters are stripped"
 (defn get-orphaned-pages
   [opts]
   (let [db (conn/get-db)]
-    (ldb/get-orphaned-pages db opts)))
+    (ldb/get-orphaned-pages db
+                            (merge opts
+                                   {:built-in-pages-names
+                                    (if (config/db-based-graph? (state/get-current-repo))
+                                      sqlite-create-graph/built-in-pages-names
+                                      gp-db/built-in-pages-names)}))))
 
 ;; FIXME: replace :logseq.macro-name with id
 (defn get-macro-blocks

src/main/frontend/handler/graph.cljs

@@ -3,11 +3,12 @@
   (:require [clojure.set :as set]
             [clojure.string :as string]
             [frontend.db :as db]
-            [logseq.db.frontend.default :as default-db]
             [frontend.state :as state]
             [frontend.util :as util]
             [frontend.handler.property.util :as pu]
             [frontend.config :as config]
+            [logseq.graph-parser.db :as gp-db]
+            [logseq.db.sqlite.create-graph :as sqlite-create-graph]
             [logseq.common.util :as common-util]))
 
 (defn- build-links
@@ -112,7 +113,9 @@
                           (seq tagged-pages)
                           (seq namespaces))
             linked (set (flatten links))
-            build-in-pages (set (map string/lower-case default-db/built-in-pages-names))
+            build-in-pages (->> (if (config/db-based-graph? repo) sqlite-create-graph/built-in-pages-names gp-db/built-in-pages-names)
+                                (map string/lower-case)
+                                set)
             nodes (cond->> (map :block/name full-pages')
                     (not builtin-pages?)
                     (remove (fn [p] (contains? build-in-pages (string/lower-case p))))

src/main/frontend/handler/page.cljs

@@ -39,6 +39,7 @@
             [datascript.core :as d]
             [frontend.db.conn :as conn]
             [logseq.db :as ldb]
+            [logseq.graph-parser.db :as gp-db]
             [frontend.modules.outliner.ui :as ui-outliner-tx]
             [frontend.modules.outliner.op :as outliner-op]))
 
@@ -227,14 +228,19 @@
 
 (defn get-all-pages
   [repo]
-  (let [db (conn/get-db repo)]
+  (let [db (conn/get-db repo)
+        graph-specific-hidden?
+        (if (config/db-based-graph? repo)
+          (fn [p]
+            (and (contains? (set (:block/type p)) "property") (ldb/built-in? db p)))
+          (fn [p]
+            (gp-db/built-in-pages-names (string/upper-case (:block/name p)))))]
     (->> (db/get-all-pages repo)
         (remove (fn [p]
                   (let [name (:block/name p)]
                     (or (util/uuid-string? name)
                         (common-config/draw? name)
-                        (db/built-in-pages-names (string/upper-case name))
-                        (and (contains? (set (:block/type p)) "property") (ldb/built-in? db p))))))
+                        (graph-specific-hidden? p)))))
         (common-handler/fix-pages-timestamps))))
 
 (defn get-filters

src/test/frontend/db/db_based_model_test.cljs

@@ -48,7 +48,7 @@
   (let [opts {:redirect? false :create-first-block? false :class? true}
         _ (page-handler/create! "class1" opts)
         _ (page-handler/create! "class2" opts)]
-    (is (= ["card" "Task" "class1" "class2"] (map first (model/get-all-classes repo))))))
+    (is (= ["Task" "card" "class1" "class2"] (sort (map first (model/get-all-classes repo)))))))
 
 (deftest get-class-objects-test
     (let [opts {:redirect? false :create-first-block? false :class? true}

src/test/frontend/fs/diff_merge_test.cljs

@@ -4,8 +4,8 @@
             [frontend.db.conn :as conn]
             [frontend.fs.diff-merge :as fs-diff]
             [frontend.handler.common.file :as file-common-handler]
-            [logseq.db :as ldb]
             [logseq.graph-parser :as graph-parser]
+            [logseq.graph-parser.db :as gp-db]
             [logseq.graph-parser.mldoc :as gp-mldoc]
             [logseq.graph-parser.text :as text]))
 
@@ -44,7 +44,7 @@
       :level 1}]))
 
 (deftest db<->ast-diff-blocks-test
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         text                                    ":PROPERTIES:
 :ID:       72289d9a-eb2f-427b-ad97-b605a4b8c59b
 :END:
@@ -285,7 +285,7 @@
       :uuid nil}]]]))
 
 (deftest db->diffblocks
-  (let [conn (ldb/start-conn)]
+  (let [conn (gp-db/start-conn)]
     (graph-parser/parse-file conn
                              "foo.md"
                              (str "- abc
@@ -364,7 +364,7 @@
 
 ;; Ensure diff-merge-uuids follows the id:: in the content
 (deftest diff-merge-uuid-extract-test
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         foo-content (str "- abc
   id:: 11451400-0000-0000-0000-000000000000\n"
                  "- def
@@ -397,7 +397,7 @@
 
 ;; Ensure diff-merge-uuids keeps the block uuids unchanged at best effort
 (deftest diff-merge-uuid-persist-test
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         foo-content (str "- abc\n"
                          "- def\n")
         bar-content (str "- ghi\n"
@@ -432,7 +432,7 @@
 
 (deftest diff-merge-error-capture-test
   ;; Any exception thrown in diff-merge-uuids-2ways should be captured and returned a nil
-  (let [conn (ldb/start-conn)
+  (let [conn (gp-db/start-conn)
         foo-content (str "- abc\n"
                          "- def\n")
         foo-new-content (str foo-content "- newline\n")]

src/test/frontend/handler/export_test.cljs

@@ -145,7 +145,7 @@
                       edn-output (edn/read-string result)]
           (is (= #{:version :blocks} (set (keys edn-output)))
                       "Correct top-level keys")
-              (is (= (sort (concat (map :block/original-name default-db/built-in-pages)
+              (is (= (sort (concat (map :block/original-name gp-db/built-in-pages)
                                                             ["page1" "page2"]))
                                 (sort (map :block/page-name (:blocks edn-output))))
                           "Correct pages")))

src/test/frontend/test/helper.cljs

@@ -28,8 +28,7 @@
                   test-db-name-db-version
                   test-db-name)]
     (state/set-current-repo! test-db)
-    (conn/start! test-db (assoc opts :create-default-pages?
-                                (get :create-default-pages? opts true)))))
+    (conn/start! test-db opts)))
 
 (defn destroy-test-db!
   []