fix: class ordered properties

deps/db/deps.edn

@@ -7,7 +7,8 @@
   cljs-bean/cljs-bean         {:mvn/version "1.5.0"}
   com.cognitect/transit-cljs   {:mvn/version "0.8.280"}
   logseq/common                {:local/root "../common"}
-  funcool/promesa              {:mvn/version "4.0.2"}}
+  funcool/promesa              {:mvn/version "4.0.2"}
+  org.flatland/ordered         {:mvn/version "1.15.11"}}
 
  :aliases
  {:clj-kondo

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

@@ -28,6 +28,9 @@
   [db current-key]
   (:v (second (d/rseek-datoms db :avet :block/order current-key))))
 
+(defn get-next-order
+  [db current-key]
+  (:v (second (d/seek-datoms db :avet :block/order current-key))))
 
 (comment
   (defn gen-n-keys
@@ -36,6 +39,4 @@
       (reset! *max-key (last ks))
       ks))
 
-  (defn get-next-order
-    [db current-key]
-    (:v (first (d/seek-datoms db :avet :block/order current-key)))))
+  )

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

@@ -1,7 +1,8 @@
 (ns logseq.db.frontend.property
   "Property related fns for DB graphs and frontend/datascript usage"
   (:require [datascript.core :as d]
-            [clojure.string :as string]))
+            [clojure.string :as string]
+            [flatland.ordered.map :refer [ordered-map]]))
 
 ;; Main property vars
 ;; ==================
@@ -22,7 +23,8 @@
    * :attribute - Property keyword that is saved to a datascript attribute outside of :block/properties
    * :closed-values - Vec of closed-value maps for properties with choices. Map
      has keys :value, :db-ident, :uuid and :icon"
-  {:block/alias           {:original-name "Alias"
+  (ordered-map
+   :block/alias           {:original-name "Alias"
                            :attribute :block/alias
                            :schema {:type :page
                                     :cardinality :many
@@ -185,7 +187,7 @@
                                              {:type :checkbox
                                               :hide? true
                                               :view-context :page
-                                              :public? true}}})
+                                              :public? true}}))
 
 (def built-in-properties
   (->> built-in-properties*
@@ -196,7 +198,7 @@
                (if (:name v)
                  v
                  (assoc v :name (keyword (string/lower-case (name k)))))]))
-       (into {})))
+       (into (ordered-map))))
 
 (def db-attribute-properties
   "Internal properties that are also db schema attributes"
@@ -291,9 +293,8 @@
 
 (defn get-class-ordered-properties
   [class-entity]
-  (let [properties (map :db/ident (:class/schema.properties class-entity))
-        ordered (get-in class-entity [:block/schema :properties])]
-    (concat ordered (remove (set ordered) properties))))
+  (->> (:class/schema.properties class-entity)
+       (sort-by :block/order)))
 
 (defn property-created-block?
   "`block` has been created in a property and it's not a closed value."

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

@@ -375,9 +375,6 @@
                                      (cond-> (select-keys m [:block/name :block/type :block/original-name :block/schema])
                                        (seq props)
                                        (assoc :block/properties (update-keys props name))
-                                       (seq (:class/schema.properties m))
-                                       (assoc-in [:block/schema :properties] (mapv (partial block-uuid->name-please-fixme m)
-                                                                                   (map :block/uuid (:class/schema.properties m))))
                                        (seq (get-in m [:block/schema :classes]))
                                        (update-in [:block/schema :classes] #(mapv block-uuid->name %))))))
                             set)))))

src/main/frontend/components/dnd.cljs

@@ -43,6 +43,7 @@
                   :onDragEnd (fn [event]
                                (let [active-id (.-id (.-active event))
                                      over-id (.-id (.-over event))]
+                                 (js/console.dir event)
                                  (when-not (= active-id over-id)
                                    (let [old-index (.indexOf ids active-id)
                                          new-index (.indexOf ids over-id)
@@ -62,7 +63,10 @@
                                            (do
                                              (set-items new-items)
                                              (on-drag-end new-values {:active-id active-id
-                                                                      :over-id over-id})))))))
+                                                                      :over-id over-id
+                                                                      :direction (if (> new-index old-index)
+                                                                                   :down
+                                                                                   :up)})))))))
                                  (set-active-id nil)))}
         sortable-opts {:items items
                        :strategy verticalListSortingStrategy}

src/main/frontend/components/property.cljs

@@ -717,35 +717,31 @@
 
 (rum/defc properties-section < rum/reactive db-mixins/query
   [block properties opts]
-  (let [class? (:class-schema? opts)]
-    (when (seq properties)
+  (when (seq properties)
       ;; Sort properties by :block/order
-      (let [properties' (sort-by (fn [[k _v]]
-                                   (:block/order (db/entity k))) properties)
-            choices (map (fn [[k v]]
-                           {:id (subs (str k) 1)
-                            :value k
-                            :content (property-cp block k v opts)}) properties')]
-        (if class?
-          (dnd/items choices
-                     {:on-drag-end (fn [properties _]
-                                     (let [schema (assoc (:block/schema block)
-                                                         :properties properties)]
-                                       (when (seq properties)
-                                         (db-property-handler/class-set-schema! (state/get-current-repo) (:block/uuid block) schema))))})
-          (dnd/items choices
-                     {:on-drag-end (fn [_ {:keys [active-id over-id]}]
-                                     (let [over (db/entity (keyword over-id))
-                                           active (db/entity (keyword active-id))
-                                           over-order (:block/order over)
-                                           prev-order (db-order/get-prev-order (db/get-db) over-order)
-                                           new-order (db-order/gen-key prev-order over-order)]
-                                       (db/transact! (state/get-current-repo)
-                                                     [{:db/id (:db/id active)
-                                                       :block/order new-order}
-                                                      (outliner-core/block-with-updated-at
-                                                       {:db/id (:db/id block)})]
-                                                     {:outliner-op :save-block})))}))))))
+    (let [properties' (sort-by (fn [[k _v]]
+                                 (:block/order (db/entity k))) properties)
+          choices (map (fn [[k v]]
+                         {:id (subs (str k) 1)
+                          :value k
+                          :content (property-cp block k v opts)}) properties')]
+      (dnd/items choices
+                 {:on-drag-end (fn [_ {:keys [active-id over-id direction]}]
+                                 (let [move-down? (= direction :down)
+                                       over (db/entity (keyword over-id))
+                                       active (db/entity (keyword active-id))
+                                       over-order (:block/order over)
+                                       new-order (if move-down?
+                                                   (let [next-order (db-order/get-next-order (db/get-db) over-order)]
+                                                     (db-order/gen-key over-order next-order))
+                                                   (let [prev-order (db-order/get-prev-order (db/get-db) over-order)]
+                                                     (db-order/gen-key prev-order over-order)))]
+                                   (db/transact! (state/get-current-repo)
+                                                 [{:db/id (:db/id active)
+                                                   :block/order new-order}
+                                                  (outliner-core/block-with-updated-at
+                                                   {:db/id (:db/id block)})]
+                                                 {:outliner-op :save-block})))}))))
 
 (defn- async-load-classes!
   [block]
@@ -776,8 +772,9 @@
         block-properties (:block/properties block)
         properties (if (and class-schema? page-configure?)
                      (->> (db-property/get-class-ordered-properties block)
+                          (map :db/ident)
                           (map #(vector % %)))
-                     (sort-by first block-properties))
+                     block-properties)
         remove-built-in-properties (fn [properties]
                                      (remove (fn [property]
                                                (let [id (if (vector? property) (first property) property)]
@@ -831,6 +828,7 @@
                                  result []]
                             (if-let [class (first classes)]
                               (let [cur-properties (->> (db-property/get-class-ordered-properties class)
+                                                        (map :db/ident)
                                                         (remove properties)
                                                         (remove hide-with-property-id))]
                                 (recur (rest classes)