chore: rename sqlite.build edn to remove mention

of schema. schema concept no longer exists and these old
names would be confusing

deps/db/script/create_graph/inferred.edn

@@ -7,15 +7,15 @@
 ;; or
 ;; - DB 3 #Meeting #Tienson
 {:auto-create-ontology? true
- :classes {:Movie {:build/schema-properties [:actor :comment]}
-           :Meeting {:build/schema-properties [:attendee :duration]}}
+ :classes {:Movie {:build/class-properties [:actor :comment]}
+           :Meeting {:build/class-properties [:attendee :duration]}}
  :properties
  {:actor {:logseq.property/type :node
           :db/cardinality :many
-          :build/schema-classes [:Person]}
+          :build/property-classes [:Person]}
   :attendee {:logseq.property/type :node
              :db/cardinality :many
-             :build/schema-classes [:Person]}}
+             :build/property-classes [:Person]}}
  :pages-and-blocks
  [{:page {:block/title "Matt-Damon" :build/tags [:Person]}}
   {:page {:block/title "Ben-Affleck" :build/tags [:Person]}}

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

@@ -144,7 +144,7 @@
 
 (defn- build-property-tx
   [properties page-uuids all-idents property-db-ids
-   [prop-name {:build/keys [schema-classes] :as prop-m}]]
+   [prop-name {:build/keys [property-classes] :as prop-m}]]
   (let [[new-block & additional-tx]
         (if-let [closed-values (seq (map #(merge {:uuid (random-uuid)} %) (:build/closed-values prop-m)))]
           (let [db-ident (get-ident all-idents prop-name)]
@@ -174,10 +174,10 @@
         new-block
         (when-let [props (not-empty (:build/properties prop-m))]
           (->block-properties (merge props (db-property-build/build-properties-with-ref-values pvalue-tx-m)) page-uuids all-idents))
-        (when (seq schema-classes)
+        (when (seq property-classes)
           {:logseq.property/classes
            (mapv #(hash-map :db/ident (get-ident all-idents %))
-                 schema-classes)})))
+                 property-classes)})))
       true
       (into additional-tx))))
 
@@ -196,7 +196,7 @@
                           (into {}))
         classes-tx (vec
                     (mapcat
-                     (fn [[class-name {:build/keys [class-parent schema-properties] :as class-m}]]
+                     (fn [[class-name {:build/keys [class-parent class-properties] :as class-m}]]
                        (let [db-ident (get-ident all-idents class-name)
                              new-block
                              (sqlite-util/build-new-class
@@ -215,17 +215,17 @@
                            (conj
                             (merge
                              new-block
-                             (dissoc class-m :build/properties :build/class-parent :build/schema-properties)
+                             (dissoc class-m :build/properties :build/class-parent :build/class-properties)
                              (when-let [props (not-empty (:build/properties class-m))]
                                (->block-properties (merge props (db-property-build/build-properties-with-ref-values pvalue-tx-m)) uuid-maps all-idents))
                              (when class-parent
                                {:logseq.property/parent
                                 (or (class-db-ids class-parent)
                                     (throw (ex-info (str "No :db/id for " class-parent) {})))})
-                             (when schema-properties
+                             (when class-properties
                                {:logseq.property.class/properties
                                 (mapv #(hash-map :db/ident (get-ident all-idents %))
-                                      schema-properties)}))))))
+                                      class-properties)}))))))
                      classes))]
     classes-tx))
 
@@ -267,7 +267,7 @@
                [:value [:or :string :double]]
                [:uuid {:optional true} :uuid]
                [:icon {:optional true} :map]]]]
-    [:build/schema-classes {:optional true} [:vector Class]]]])
+    [:build/property-classes {:optional true} [:vector Class]]]])
 
 (def Classes
   [:map-of
@@ -275,7 +275,7 @@
    [:map
     [:build/properties {:optional true} User-properties]
     [:build/class-parent {:optional true} Class]
-    [:build/schema-properties {:optional true} [:vector Property]]]])
+    [:build/class-properties {:optional true} [:vector Property]]]])
 
 (def Options
   [:map
@@ -289,7 +289,7 @@
 
 (defn- get-used-properties-from-options
   "Extracts all used properties as a map of properties to their property values. Looks at properties
-   from :build/properties and :build/schema-properties. Properties from :block/schema-properties have
+   from :build/properties and :build/class-properties. Properties from :build/class-properties have
    a ::no-value value"
   [{:keys [pages-and-blocks properties classes]}]
   (let [page-block-properties (->> pages-and-blocks
@@ -299,7 +299,7 @@
         property-properties (->> (vals properties)
                                  (mapcat #(into [] (:build/properties %))))
         class-properties (->> (vals classes)
-                              (mapcat #(concat (map (fn [p] [p ::no-value]) (:build/schema-properties %))
+                              (mapcat #(concat (map (fn [p] [p ::no-value]) (:build/class-properties %))
                                                (into [] (:build/properties %))))
                               set)
         props-to-values (->> (set/union class-properties page-block-properties property-properties)
@@ -583,7 +583,7 @@
      Additional keys available:
      * :build/properties - Define properties on a property page.
      * :build/closed-values - Define closed values with a vec of maps. A map contains keys :uuid, :value and :icon.
-     * :build/schema-classes - Vec of class name keywords. Defines a property's range classes
+     * :build/property-classes - Vec of class name keywords. Defines a property's range classes
      * :build/properties-ref-types - Map of internal ref types to public ref types that are valid only for this property.
        Useful when remapping value ref types e.g. for :logseq.property/default-value
    * :classes - This is a map to configure classes where the keys are class name keywords
@@ -591,7 +591,7 @@
      Additional keys available:
      * :build/properties - Define properties on a class page
      * :build/class-parent - Add a class parent by its keyword name
-     * :build/schema-properties - Vec of property name keywords. Defines properties that a class gives to its objects
+     * :build/class-properties - Vec of property name keywords. Defines properties that a class gives to its objects
   * :graph-namespace - namespace to use for db-ident creation. Useful when importing an ontology
   * :auto-create-ontology? - When set to true, creates properties and classes from their use.
     See auto-create-ontology for more details

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

@@ -146,7 +146,7 @@
      (let [title' (or title (name db-ident))]
        (mark-block-as-built-in
         (sqlite-util/build-new-class
-         (let [schema-properties (mapv
+         (let [class-properties (mapv
                                   (fn [db-ident]
                                     (let [property (get db-ident->properties db-ident)]
                                       (assert property (str "Built-in property " db-ident " is not defined yet"))
@@ -157,8 +157,8 @@
              :block/name (common-util/page-name-sanity-lc title')
              :db/ident db-ident
              :block/uuid (common-uuid/gen-uuid :db-ident-block-uuid db-ident)}
-             (seq schema-properties)
-             (assoc :logseq.property.class/properties schema-properties)
+             (seq class-properties)
+             (assoc :logseq.property.class/properties class-properties)
              (seq properties)
              (merge properties)))))))
    built-in-classes))

deps/outliner/test/logseq/outliner/property_test.cljs

@@ -279,15 +279,15 @@
 
 (deftest class-remove-property!
   (let [conn (db-test/create-conn-with-blocks
-              {:classes {:c1 {:build/schema-properties [:p1 :p2]}}})
+              {:classes {:c1 {:build/class-properties [:p1 :p2]}}})
         _ (outliner-property/class-remove-property! conn :user.class/c1 :user.property/p1)]
     (is (= [:user.property/p2]
            (map :db/ident (:logseq.property.class/properties (d/entity @conn :user.class/c1)))))))
 
 (deftest get-block-classes-properties
   (let [conn (db-test/create-conn-with-blocks
-              {:classes {:c1 {:build/schema-properties [:p1]}
-                         :c2 {:build/schema-properties [:p2 :p3]}}
+              {:classes {:c1 {:build/class-properties [:p1]}
+                         :c2 {:build/class-properties [:p2 :p3]}}
                :pages-and-blocks
                [{:page {:block/title "p1"}
                  :blocks [{:block/title "o1"

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

@@ -170,7 +170,7 @@
      :properties
      (->> db-property-type/user-built-in-property-types
           (mapcat #(cond-> (if (= :node %)
-                             [[% {:logseq.property/type % :build/schema-classes [:TestClass]}]
+                             [[% {:logseq.property/type % :build/property-classes [:TestClass]}]
                               [:node-without-classes {:logseq.property/type %}]]
                              [[% {:logseq.property/type %}]])
                      (contains? db-property-type/cardinality-property-types %)
@@ -178,7 +178,7 @@
                             (cond-> {:logseq.property/type %
                                      :db/cardinality :many}
                               (= :node %)
-                              (assoc :build/schema-classes [:TestClass]))])))
+                              (assoc :build/property-classes [:TestClass]))])))
           (into (mapv #(vector (keyword (str (name %) "-closed"))
                                {:logseq.property/type %
                                 :build/closed-values (closed-values-config (keyword (str (name %) "-closed")))})

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

@@ -69,7 +69,7 @@
       parent-class'
       (assoc :build/class-parent (keyword (strip-schema-prefix parent-class')))
       (seq properties)
-      (assoc :build/schema-properties (mapv (comp keyword strip-schema-prefix) properties)))))
+      (assoc :build/class-properties (mapv (comp keyword strip-schema-prefix) properties)))))
 
 (def schema->logseq-data-types
   "Schema datatypes, https://schema.org/DataType, mapped to their Logseq equivalents"
@@ -123,7 +123,7 @@
        (= schema-type :node)
        (assoc :db/cardinality :many)
        (= schema-type :node)
-       (assoc :build/schema-classes (mapv (comp keyword strip-schema-prefix) range-includes)))}))
+       (assoc :build/property-classes (mapv (comp keyword strip-schema-prefix) range-includes)))}))
 
 (defn- get-class-to-properties
   "Given a vec of class ids and a vec of properties map to process, return a map of
@@ -334,8 +334,8 @@
           (let [select-class-ids' (->> select-class-ids (map (comp keyword strip-schema-prefix)) set)]
             (-> properties
                 (update-vals (fn [m]
-                               (if (:build/schema-classes m)
-                                 (update m :build/schema-classes
+                               (if (:build/property-classes m)
+                                 (update m :build/property-classes
                                          (fn [cs] (vec (set (filter #(contains? select-class-ids' %) cs)))))
                                  m)))))
           properties)

src/test/frontend/db/db_based_model_test.cljs

@@ -58,8 +58,8 @@
   (let [conn (db-test/create-conn-with-blocks
               {:properties {:prop1 {:logseq.property/type :default}}
                :classes
-               {:Class1 {:build/schema-properties [:prop1]}
-                :Class2 {:build/schema-properties [:prop1]}}})
+               {:Class1 {:build/class-properties [:prop1]}
+                :Class2 {:build/class-properties [:prop1]}}})
         property (d/entity @conn :user.property/prop1)
         classes (with-redefs [conn/get-db (constantly @conn)]
                   (model/get-classes-with-property (:db/ident property)))]

src/test/frontend/db/query_dsl_test.cljs

@@ -212,7 +212,7 @@ prop-d:: [[nada]]"}])
                  :build/properties
                  {:logseq.property/default-value "foo"}
                  :build/properties-ref-types {:entity :number}}}
-      :classes {:Class1 {:build/schema-properties [:default]}}
+      :classes {:Class1 {:build/class-properties [:default]}}
       :pages-and-blocks
       [{:page {:block/title "page1"}
         :blocks [{:block/title "b1"
@@ -238,7 +238,7 @@ prop-d:: [[nada]]"}])
       {:checkbox {:logseq.property/type :checkbox
                   :build/properties
                   {:logseq.property/scalar-default-value true}}}
-      :classes {:Class1 {:build/schema-properties [:checkbox]}}
+      :classes {:Class1 {:build/class-properties [:checkbox]}}
       :pages-and-blocks
       [{:page {:block/title "page1"}
         :blocks [{:block/title "b1"
@@ -268,7 +268,7 @@ prop-d:: [[nada]]"}])
                 :build/properties
                 {:logseq.property/default-value "Todo"}
                 :build/properties-ref-types {:entity :number}}}
-      :classes {:Mytask {:build/schema-properties [:status]}
+      :classes {:Mytask {:build/class-properties [:status]}
                 :Bug {:build/class-parent :Mytask}}
       :pages-and-blocks
       [{:page {:block/title "page1"}