fix: inlined db-based-graph? calls in db-property

Addressed fixmes for db-based-graph fns that were inlined to prevent
circular dependencies b/n db-property and sqlite-util.  Moved multi
graph fns to db-property-util and existing db-property-util to
db-property-build to address this

.clj-kondo/config.edn

@@ -140,6 +140,7 @@
              logseq.db.frontend.content db-content
              logseq.db.frontend.inputs db-inputs
              logseq.db.frontend.property db-property
+             logseq.db.frontend.property.build db-property-build
              logseq.db.frontend.property.type db-property-type
              logseq.db.frontend.property.util db-property-util
              logseq.db.frontend.rules rules

deps/db/.carve/config.edn

@@ -5,6 +5,7 @@
                   logseq.db.sqlite.util
                   logseq.db.sqlite.cli
                   logseq.db.frontend.property
+                  logseq.db.frontend.property.build
                   logseq.db.frontend.property.util
                   logseq.db.frontend.content
                   logseq.db.sqlite.create-graph

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

@@ -262,38 +262,10 @@
   ;; Disallow tags or page refs as they would create unreferenceable page names
   (not (re-find #"^(#|\[\[)" s)))
 
-(defn get-pid
-  "Get a built-in property's id (keyword name for file graph and db-ident for db
-  graph) given its db-ident. No need to use this fn in a db graph only context"
-  [repo db-ident]
-  ;; FIXME: Use db-based-graph? when this fn moves to another ns
-  (if (string/starts-with? repo "logseq_db_")
-    db-ident
-    (get-in built-in-properties [db-ident :name])))
-
-(defn lookup
-  "Get the value of coll by db-ident. For file and db graphs"
-  [repo coll db-ident]
-  (get coll (get-pid repo db-ident)))
-
 (defn get-pair-e
   [block db-ident]
   (first (filter #(= (:db/ident (:property/pair-property %)) db-ident) (:block/raw-properties block))))
 
-(defn get-block-property-value
-  "Get the value of built-in block's property by its db-ident"
-  [repo db block db-ident]
-  (when db
-    (let [block (or (d/entity db (:db/id block)) block)]
-      ;; FIXME: Use db-based-graph? when this fn moves to another ns
-      (if (string/starts-with? repo "logseq_db_")
-        (get (get-pair-e block db-ident) db-ident)
-        (lookup repo (:block/properties block) db-ident)))))
-
-(defn shape-block?
-  [repo db block]
-  (= :whiteboard-shape (get-block-property-value repo db block :logseq.property/ls-type)))
-
 (defn get-closed-property-values
   [db property-id]
   (when-let [property (d/entity db property-id)]

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

@@ -0,0 +1,76 @@
+(ns logseq.db.frontend.property.build
+  "Builds core property concepts"
+  (:require [logseq.db.sqlite.util :as sqlite-util]
+            [logseq.db.frontend.property.type :as db-property-type]))
+
+(defonce hidden-page-name-prefix "$$$")
+
+(defn- closed-value-new-block
+  [page-id block-id value property]
+  {:block/type #{"closed value"}
+   :block/format :markdown
+   :block/uuid block-id
+   :block/page page-id
+   :block/properties [(sqlite-util/build-property-pair :logseq.property/created-from-property (:db/ident property))]
+   :block/schema {:value value}
+   :block/parent page-id})
+
+(defn build-closed-value-block
+  "Builds a closed value block to be transacted"
+  [block-uuid block-value page-id property {:keys [db-ident icon description]}]
+  (assert block-uuid (uuid? block-uuid))
+  (cond->
+   (closed-value-new-block page-id block-uuid block-value property)
+    (and db-ident (keyword? db-ident))
+    (assoc :db/ident db-ident)
+
+    icon
+    (update :block/properties conj (sqlite-util/build-property-pair :logseq.property/icon icon))
+
+    ;; For now, only closed values with :db/ident are built-in?
+    (and db-ident (keyword? db-ident))
+    sqlite-util/mark-block-as-built-in
+
+    description
+    (update :block/schema assoc :description description)
+
+    true
+    sqlite-util/block-with-timestamps))
+
+(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))]
+    (-> (sqlite-util/build-new-page page-name)
+        (assoc :block/type #{"hidden"}))))
+
+(defn build-closed-values
+  "Builds all the tx needed for property with closed values including
+   the hidden page and closed value blocks as needed"
+  [db-ident prop-name property {:keys [translate-closed-page-value-fn property-attributes]
+                                :or {translate-closed-page-value-fn identity}}]
+  (let [ref-type? (contains? (set (remove #{:default} db-property-type/ref-property-types))
+                             (get-in property [:block/schema :type]))
+        property-schema (assoc (:block/schema property)
+                               :values
+                               (if ref-type?
+                                 (mapv translate-closed-page-value-fn (:closed-values property))
+                                 (mapv :uuid (:closed-values property))))
+        property-tx (merge (sqlite-util/build-new-property db-ident property-schema {:original-name prop-name})
+                           property-attributes)
+        hidden-tx
+        ;; closed ref types don't have hidden tx
+        (if ref-type?
+          []
+          (let [page-tx (build-property-hidden-page property-tx)
+                closed-value-blocks-tx
+                (map (fn [{:keys [db-ident value icon description uuid]}]
+                       (build-closed-value-block
+                        uuid
+                        value
+                        [:block/uuid (:block/uuid page-tx)]
+                        property
+                        {:db-ident db-ident :icon icon :description description}))
+                     (:closed-values property))]
+            (into [page-tx] closed-value-blocks-tx)))]
+    (into [property-tx] hidden-tx)))

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

@@ -1,76 +1,31 @@
 (ns logseq.db.frontend.property.util
-  "Util fns for building core property concepts"
-  (:require [logseq.db.sqlite.util :as sqlite-util]
-            [logseq.db.frontend.property.type :as db-property-type]))
-
-(defonce hidden-page-name-prefix "$$$")
-
-(defn- closed-value-new-block
-  [page-id block-id value property]
-  {:block/type #{"closed value"}
-   :block/format :markdown
-   :block/uuid block-id
-   :block/page page-id
-   :block/properties [(sqlite-util/build-property-pair :logseq.property/created-from-property (:db/ident property))]
-   :block/schema {:value value}
-   :block/parent page-id})
-
-(defn build-closed-value-block
-  "Builds a closed value block to be transacted"
-  [block-uuid block-value page-id property {:keys [db-ident icon description]}]
-  (assert block-uuid (uuid? block-uuid))
-  (cond->
-   (closed-value-new-block page-id block-uuid block-value property)
-    (and db-ident (keyword? db-ident))
-    (assoc :db/ident db-ident)
-
-    icon
-    (update :block/properties conj (sqlite-util/build-property-pair :logseq.property/icon icon))
-
-    ;; For now, only closed values with :db/ident are built-in?
-    (and db-ident (keyword? db-ident))
-    sqlite-util/mark-block-as-built-in
-
-    description
-    (update :block/schema assoc :description description)
-
-    true
-    sqlite-util/block-with-timestamps))
-
-(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))]
-    (-> (sqlite-util/build-new-page page-name)
-        (assoc :block/type #{"hidden"}))))
-
-(defn build-closed-values
-  "Builds all the tx needed for property with closed values including
-   the hidden page and closed value blocks as needed"
-  [db-ident prop-name property {:keys [translate-closed-page-value-fn property-attributes]
-                                :or {translate-closed-page-value-fn identity}}]
-  (let [ref-type? (contains? (set (remove #{:default} db-property-type/ref-property-types))
-                             (get-in property [:block/schema :type]))
-        property-schema (assoc (:block/schema property)
-                               :values
-                               (if ref-type?
-                                 (mapv translate-closed-page-value-fn (:closed-values property))
-                                 (mapv :uuid (:closed-values property))))
-        property-tx (merge (sqlite-util/build-new-property db-ident property-schema {:original-name prop-name})
-                           property-attributes)
-        hidden-tx
-        ;; closed ref types don't have hidden tx
-        (if ref-type?
-          []
-          (let [page-tx (build-property-hidden-page property-tx)
-                closed-value-blocks-tx
-                (map (fn [{:keys [db-ident value icon description uuid]}]
-                       (build-closed-value-block
-                        uuid
-                        value
-                        [:block/uuid (:block/uuid page-tx)]
-                        property
-                        {:db-ident db-ident :icon icon :description description}))
-                     (:closed-values property))]
-            (into [page-tx] closed-value-blocks-tx)))]
-    (into [property-tx] hidden-tx)))
+  "Property related util fns. Fns used in both DB and file graphs should go here"
+  (:require [logseq.db.frontend.property :as db-property]
+            [datascript.core :as d]
+            [logseq.db.sqlite.util :as sqlite-util]))
+
+(defn get-pid
+  "Get a built-in property's id (keyword name for file graph and db-ident for db
+  graph) given its db-ident. No need to use this fn in a db graph only context"
+  [repo db-ident]
+  (if (sqlite-util/db-based-graph? repo)
+    db-ident
+    (get-in db-property/built-in-properties [db-ident :name])))
+
+(defn lookup
+  "Get the value of coll by db-ident. For file and db graphs"
+  [repo coll db-ident]
+  (get coll (get-pid repo db-ident)))
+
+(defn get-block-property-value
+  "Get the value of built-in block's property by its db-ident"
+  [repo db block db-ident]
+  (when db
+    (let [block (or (d/entity db (:db/id block)) block)]
+      (if (sqlite-util/db-based-graph? repo)
+        (get (db-property/get-pair-e block db-ident) db-ident)
+        (lookup repo (:block/properties block) db-ident)))))
+
+(defn shape-block?
+  [repo db block]
+  (= :whiteboard-shape (get-block-property-value repo db block :logseq.property/ls-type)))

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

@@ -4,7 +4,7 @@
             [logseq.db.frontend.schema :as db-schema]
             [logseq.db.frontend.property :as db-property]
             [logseq.db.frontend.class :as db-class]
-            [logseq.db.frontend.property.util :as db-property-util]
+            [logseq.db.frontend.property.build :as db-property-build]
             [logseq.common.util :as common-util]
             [datascript.core :as d]))
 
@@ -14,7 +14,7 @@
    (fn [[db-ident {:keys [schema original-name closed-values] :as m}]]
      (let [prop-name (or original-name (name (:name m)))
            blocks (if closed-values
-                    (db-property-util/build-closed-values
+                    (db-property-build/build-closed-values
                      db-ident
                      prop-name
                      {:db/ident db-ident :block/schema schema :closed-values closed-values}

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

@@ -1,6 +1,6 @@
 (ns logseq.graph-parser.whiteboard
   "Whiteboard related parser utilities"
-  (:require [logseq.db.frontend.property :as db-property]
+  (:require [logseq.db.frontend.property.util :as db-property-util]
             [logseq.db.sqlite.util :as sqlite-util]))
 
 (defn block->shape [block]
@@ -80,8 +80,8 @@
            {:block/page page-id})))
 
 (defn shape->block [repo shape page-id]
-  (let [properties {(db-property/get-pid repo :logseq.property/ls-type) :whiteboard-shape
-                    (db-property/get-pid repo :logseq.property.tldraw/shape) shape}
+  (let [properties {(db-property-util/get-pid repo :logseq.property/ls-type) :whiteboard-shape
+                    (db-property-util/get-pid repo :logseq.property.tldraw/shape) shape}
         block {:block/uuid (if (uuid? (:id shape)) (:id shape) (uuid (:id shape)))
                :block/page page-id
                :block/parent page-id}

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

@@ -15,7 +15,7 @@
             [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.frontend.property.util :as db-property-util]
             [logseq.db.sqlite.util :as sqlite-util]
             [cljs.pprint :as pprint]
             [logseq.common.marker :as common-marker]
@@ -648,8 +648,8 @@
   (let [db @conn
         tb (when target-block (block db target-block))
         target-block (if sibling? target-block (when tb (:block (otree/-get-down tb conn))))
-        list-type-fn (fn [block] (db-property/get-block-property-value repo db block :logseq.property/order-list-type))
-        k (db-property/get-pid repo :logseq.property/order-list-type)
+        list-type-fn (fn [block] (db-property-util/get-block-property-value repo db block :logseq.property/order-list-type))
+        k (db-property-util/get-pid repo :logseq.property/order-list-type)
         db-based? (sqlite-util/db-based-graph? repo)]
     (if-let [list-type (and target-block (list-type-fn target-block))]
       (mapv

deps/outliner/src/logseq/outliner/tree.cljs

@@ -1,7 +1,7 @@
 (ns logseq.outliner.tree
   "Provides tree fns and INode protocol"
   (:require [logseq.db :as ldb]
-            [logseq.db.frontend.property :as db-property]
+            [logseq.db.frontend.property.util :as db-property-util]
             [datascript.core :as d]))
 
 (defprotocol INode
@@ -24,7 +24,7 @@
 (defn- blocks->vec-tree-aux
   [repo db blocks root]
   (let [root-id (:db/id root)
-        blocks (remove #(db-property/shape-block? repo db %) blocks)
+        blocks (remove #(db-property-util/shape-block? repo db %) blocks)
         parent-blocks (group-by #(get-in % [:block/parent :db/id]) blocks) ;; exclude whiteboard shapes
         sort-fn (fn [parent]
                   (when-let [children (get parent-blocks parent)]

scripts/src/logseq/tasks/db_graph/create_graph.cljs

@@ -6,7 +6,7 @@
   (:require [logseq.db.sqlite.db :as sqlite-db]
             [logseq.db.sqlite.util :as sqlite-util]
             [logseq.db.sqlite.create-graph :as sqlite-create-graph]
-            [logseq.db.frontend.property.util :as db-property-util]
+            [logseq.db.frontend.property.build :as db-property-build]
             [logseq.outliner.cli.pipeline :as cli-pipeline]
             [logseq.common.util :as common-util]
             [clojure.string :as string]
@@ -173,7 +173,7 @@
                             (fn [[prop-name]]
                               (if (get-in properties [prop-name :closed-values])
                                 (let [db-ident (db-property/create-user-property-ident-from-name (name prop-name))]
-                                  (db-property-util/build-closed-values
+                                  (db-property-build/build-closed-values
                                    db-ident
                                    prop-name
                                    (assoc (get properties prop-name) :db/ident db-ident)

src/main/frontend/handler/db_based/property.cljs

@@ -12,7 +12,7 @@
             [logseq.common.util :as common-util]
             [logseq.db.sqlite.util :as sqlite-util]
             [logseq.db.frontend.property.type :as db-property-type]
-            [logseq.db.frontend.property.util :as db-property-util]
+            [logseq.db.frontend.property.build :as db-property-build]
             [malli.util :as mu]
             [malli.error :as me]
             [logseq.common.util.page-ref :as page-ref]
@@ -592,9 +592,9 @@
 
 (defn- get-property-hidden-page
   [property]
-  (let [page-name (str db-property-util/hidden-page-name-prefix (:block/uuid property))]
+  (let [page-name (str db-property-build/hidden-page-name-prefix (:block/uuid property))]
     (or (db/get-page page-name)
-        (db-property-util/build-property-hidden-page property))))
+        (db-property-build/build-property-hidden-page property))))
 
 (defn re-init-commands!
   "Update commands after task status and priority's closed values has been changed"
@@ -677,7 +677,7 @@
                                 (if (contains? db-property-type/ref-property-types (:type property-schema))
                                   []
                                   (let [page (get-property-hidden-page property)
-                                        new-block (db-property-util/build-closed-value-block block-id resolved-value [:block/uuid (:block/uuid page)]
+                                        new-block (db-property-build/build-closed-value-block block-id resolved-value [:block/uuid (:block/uuid page)]
                                                                                              property {:icon icon
                                                                                                        :description description})]
                                     (cond-> []
@@ -717,7 +717,7 @@
                 page-tx (when-not (e/entity? page) page)
                 page-id (:block/uuid page)
                 closed-value-blocks (map (fn [value]
-                                           (db-property-util/build-closed-value-block
+                                           (db-property-build/build-closed-value-block
                                             (db/new-block-id)
                                             value
                                             [:block/uuid page-id]

src/main/frontend/handler/property/util.cljs

@@ -6,13 +6,14 @@
             [frontend.db :as db]
             [datascript.core :as d]
             [logseq.db.sqlite.util :as sqlite-util]
-            [logseq.db.frontend.property :as db-property]))
+            [logseq.db.frontend.property :as db-property]
+            [logseq.db.frontend.property.util :as db-property-util]))
 
 (defn lookup
   "Get the value of coll's (a map) by db-ident. For file and db graphs"
   [coll key]
   (let [repo (state/get-current-repo)]
-    (db-property/lookup repo coll key)))
+    (db-property-util/lookup repo coll key)))
 
 (defn lookup-by-name
   "Get the value of coll's (a map) by name. Only use this
@@ -33,13 +34,13 @@
   [block db-ident]
   (let [repo (state/get-current-repo)
         db (db/get-db repo)]
-    (db-property/get-block-property-value repo db block db-ident)))
+    (db-property-util/get-block-property-value repo db block db-ident)))
 
 (defn get-pid
   "Get a built-in property's id (db-ident or name) given its db-ident. For file and db graphs"
   [db-ident]
   (let [repo (state/get-current-repo)]
-    (db-property/get-pid repo db-ident)))
+    (db-property-util/get-pid repo db-ident)))
 
 (defn block->shape [block]
   (get-block-property-value block :logseq.property.tldraw/shape))
@@ -51,7 +52,7 @@
   [block]
   (let [repo (state/get-current-repo)
         db (db/get-db repo)]
-    (db-property/shape-block? repo db block)))
+    (db-property-util/shape-block? repo db block)))
 
 (defn get-closed-property-values
   [property-id]

src/main/logseq/api.cljs

@@ -51,7 +51,7 @@
             [frontend.handler.search :as search-handler]
             [logseq.api.block :as api-block]
             [logseq.db :as ldb]
-            [logseq.db.frontend.property :as db-property]))
+            [logseq.db.frontend.property.util :as db-property-util]))
 
 ;; Alert: this namespace shouldn't invoke any reactive queries
 
@@ -1029,7 +1029,7 @@
             repo (state/get-current-repo)]
       (if (or (not block) (true? overwrite))
         (do (when-let [old-target block]
-              (let [k (db-property/get-pid repo :logseq.property/template)]
+              (let [k (db-property-util/get-pid repo :logseq.property/template)]
                 (property-handler/remove-block-property! repo (:block/uuid old-target) k)))
             (property-handler/set-block-property! repo target-uuid :logseq.property/template template-name))
         (throw (js/Error. "Template already exists!"))))))
@@ -1039,7 +1039,7 @@
   (p/let [block (when name (db-async/<get-template-by-name name))]
     (when block
       (let [repo (state/get-current-repo)
-            k (db-property/get-pid repo :logseq.property/template)]
+            k (db-property-util/get-pid repo :logseq.property/template)]
         (property-handler/remove-block-property! repo (:block/uuid block) k)))))
 
 ;; search