feat(rtc): support :block/alias sync

also update `ref-type-attributes`, `card-many-attributes`,
`card-many-ref-type-attributes`, `card-one-ref-type-attributes`
in ns `logseq.db.schema`

deps/db/src/logseq/db/schema.cljs

@@ -1,5 +1,6 @@
 (ns logseq.db.schema
-  "Main db schemas for the Logseq app")
+  "Main db schemas for the Logseq app"
+  (:require [clojure.set :as set]))
 
 (defonce version 2)
 (defonce ast-version 1)
@@ -159,16 +160,23 @@
     :block/alias
     :block/tags})
 
-;; FIXME: replace with a fn that's synced with schema
+
 (def ref-type-attributes
-  #{:block/link
-    :block/parent
-    :block/left
-    :block/page
-    :block/refs
-    :block/path-refs
-    :block/tags
-    :block/alias
-    :block/namespace
-    :block/macros
-    :block/file})
+  (into #{}
+        (keep (fn [[attr-name attr-body-map]]
+                (when (= :db.type/ref (:db/valueType attr-body-map))
+                  attr-name)))
+        schema))
+
+(def card-many-attributes
+  (into #{}
+        (keep (fn [[attr-name attr-body-map]]
+                (when (= :db.cardinality/many (:db/cardinality attr-body-map))
+                  attr-name)))
+        schema))
+
+(def card-many-ref-type-attributes
+  (set/intersection card-many-attributes ref-type-attributes))
+
+(def card-one-ref-type-attributes
+  (set/difference ref-type-attributes card-many-attributes))

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

@@ -55,10 +55,17 @@
          ;; This fn should match pipeline/datom->av-vector
          (map (fn m->av-vector [[a v]]
                 [a v]
-                (if (contains? db-schema/ref-type-attributes a)
-                  [a
-                   [:block/uuid (str (some #(when (= (:db/id %) (:db/id v)) (:block/uuid %)) blocks))]]
-                  [a v])))
+                (cond
+                  (contains? db-schema/card-one-ref-type-attributes a)
+                  [a [:block/uuid (str (some #(when (= (:db/id %) (:db/id v)) (:block/uuid %)) blocks))]]
+
+                  (contains? db-schema/card-many-ref-type-attributes a)
+                  [a (seq
+                      (map (fn [{db-id :db/id}]
+                             [:block/uuid (some #(when (= db-id (:db/id %)) (:block/uuid %)) blocks)])
+                           v))]
+                  :else [a v]
+                  )))
          (transit/write t-writer))))
 
 (defn block-with-timestamps
@@ -99,4 +106,4 @@
                                   :block/uuid (d/squuid)
                                   :block/type "property"})))
                             db-property/built-in-properties)]
-    (concat initial-files default-properties)))
+    (concat initial-files default-properties)))

src/main/frontend/db/rtc/core.cljs

@@ -64,7 +64,8 @@
         [:self :string]
         [:content {:optional true} :string]
         [:updated-at {:optional true} :int]
-        [:created-at {:optional true} :int]]
+        [:created-at {:optional true} :int]
+        [:alias {:optional true} [:maybe [:sequential :uuid]]]]
        [:map
         [:op [:enum :remove]]
         [:block-uuid :string]]
@@ -75,7 +76,8 @@
         [:self :string]
         [:content {:optional true} :string]
         [:updated-at {:optional true} :int]
-        [:created-at {:optional true} :int]]
+        [:created-at {:optional true} :int]
+        [:alias {:optional true} [:maybe [:sequential :uuid]]]]
        [:map
         [:op [:enum :update-page]]
         [:self :string]
@@ -187,14 +189,20 @@
       :else nil)))
 
 (defn- update-block-attrs
-  [repo block-uuid content updated-at created-at]
-  (when (or content updated-at created-at)
+  [repo block-uuid content updated-at created-at alias]
+  (when (or content updated-at created-at alias)
     (let [b-ent (db/entity repo [:block/uuid block-uuid])
+          alias-target-ids (some->> (seq alias)
+                                    (map (partial vector :block/uuid))
+                                    (db/pull-many repo '[:db/id])
+                                    (keep :db/id))
           new-block
           (cond-> (db/pull repo '[*] (:db/id b-ent))
             updated-at (assoc :block/updated-at updated-at)
             created-at (assoc :block/created-at created-at)
-            (and content (not= content (:block/content b-ent))) (assoc :block/content content))]
+            (and content (not= content (:block/content b-ent))) (assoc :block/content content)
+            true (assoc :block/alias alias-target-ids))]
+
       (outliner-tx/transact!
        {:persist-op? false}
        (outliner-core/save-block! new-block)))))
@@ -203,7 +211,7 @@
   [state sorted-move-ops]
   {:pre [(some? @(:*repo state))]}
   (prn :sorted-move-ops sorted-move-ops)
-  (doseq [{:keys [parents left self content updated-at created-at]} sorted-move-ops]
+  (doseq [{:keys [parents left self content updated-at created-at alias]} sorted-move-ops]
     (let [r (check-block-pos state self parents left)]
       (case r
         :not-exist
@@ -212,7 +220,7 @@
         (insert-or-move-block state self parents left true)
         nil                             ; do nothing
         nil)
-      (update-block-attrs @(:*repo state) (uuid self) content updated-at created-at)
+      (update-block-attrs @(:*repo state) (uuid self) content updated-at created-at alias)
       (prn :apply-remote-move-ops self r parents left))))
 
 
@@ -221,7 +229,7 @@
   {:pre [(some? @(:*repo state))]}
   (let [repo @(:*repo state)]
     (prn :update-ops update-ops)
-    (doseq [{:keys [parents left self content created-at updated-at]} update-ops]
+    (doseq [{:keys [parents left self content created-at updated-at alias]} update-ops]
       (let [r (check-block-pos state self parents left)]
         (case r
           :not-exist
@@ -229,7 +237,7 @@
           :wrong-pos
           (insert-or-move-block state self parents left true)
           nil)
-        (update-block-attrs repo (uuid self) content updated-at created-at)
+        (update-block-attrs repo (uuid self) content updated-at created-at alias)
         (prn :apply-remote-update-ops r self)))))
 
 (defn apply-remote-update-page-ops
@@ -359,13 +367,20 @@
                          (keep (fn [block-uuid]
                                  (when-let [b (db/entity repo [:block/uuid (uuid block-uuid)])]
                                    (let [left-uuid (some-> b :block/left :block/uuid str)
-                                         parent-uuid (some-> b :block/parent :block/uuid str)]
-                                     (when (and left-uuid parent-uuid)
-                                       [:update {:block-uuid block-uuid
-                                                 :target-uuid left-uuid :sibling? (not= left-uuid parent-uuid)
-                                                 :content (:block/content b "")
-                                                 :updated-at (:block/updated-at b)
-                                                 :created-at (:block/created-at b)}]))))))
+                                         parent-uuid (some-> b :block/parent :block/uuid str)
+                                         alias-block-uuids (some->> (seq (:block/alias b))
+                                                                    (keep :db/id)
+                                                                    (db/pull-many repo [:block/uuid])
+                                                                    (map (comp str :block/uuid)))]
+                                     (prn ::debug alias-block-uuids)
+                                     [:update
+                                      (cond-> {:block-uuid block-uuid
+                                               :alias alias-block-uuids}
+                                        (:block/updated-at b) (assoc :updated-at (:block/updated-at b))
+                                        (:block/created-at b) (assoc :updated-at (:block/created-at b))
+                                        (:block/content b) (assoc :content (:block/content b))
+                                        (and left-uuid parent-uuid) (assoc :target-uuid left-uuid
+                                                                           :sibling? (not= left-uuid parent-uuid)))])))))
         update-page-ops* (->> update-page-uuids
                               (keep (fn [block-uuid]
                                       (when-let [page-name (:block/name (db/entity repo [:block/uuid (uuid block-uuid)]))]

src/main/frontend/db/rtc/db_listener.cljs

@@ -12,7 +12,12 @@
                           (and add? (contains? #{:block/left :block/parent} a))
                           (conj r :move)
 
-                          (and (not add?) (contains? #{:block/content} a))
+                          (and add? (contains? #{:block/content} a))
+                          (conj r :update)
+
+                          ;; :block/alias is card-many,
+                          ;; not matter add? is true or false, consider as update
+                          (contains? #{:block/alias} a)
                           (conj r :update)
 
                           (and (not add?) (= :block/uuid a))
@@ -69,7 +74,7 @@
             (let [ops (loop [[datom & others] same-entity-datoms]
                         (when-let [[_e a _v _t _add?] datom]
                           (cond
-                            (contains? #{:block/parent :block/left :block/content} a)
+                            (contains? #{:block/parent :block/left :block/content :block/alias} a)
                             (gen-block-ops repo same-entity-datoms)
 
                             (contains? #{:block/name} a)

src/main/frontend/db/rtc/full_upload_download_graph.cljs

@@ -13,7 +13,8 @@
             [logseq.db.schema :as db-schema]
             [logseq.db.sqlite.util :as sqlite-util]
             [frontend.persist-db :as persist-db]
-            [frontend.db.rtc.op :as op]))
+            [frontend.db.rtc.op :as op]
+            [logseq.outliner.pipeline :as outliner-pipeline]))
 
 
 (defn- export-as-blocks
@@ -59,10 +60,12 @@
    (fn [block]
      (let [db-id (:db/id block)
            block-parent (:db/id (:block/parent block))
-           block-left (:db/id (:block/left block))]
+           block-left (:db/id (:block/left block))
+           block-alias (map :db/id (:block/alias block))]
        (cond-> (assoc block :db/id (str db-id))
          block-parent (assoc :block/parent (str block-parent))
-         block-left (assoc :block/left (str block-left)))))
+         block-left (assoc :block/left (str block-left))
+         (seq block-alias) (assoc :block/alias (map str block-alias)))))
    blocks))
 
 (def page-of-block
@@ -100,11 +103,7 @@
       (let [db (d/db conn)
             blocks*
             (d/pull-many db '[*] (keep (fn [b] (when-let [uuid (:block/uuid b)] [:block/uuid uuid])) blocks))
-            blocks**
-            (mapv (fn [b]
-                    (cond-> (assoc b :datoms (sqlite-util/block-map->datoms-str blocks* b))
-                      (:block/parent b) (assoc :page_uuid (str (:block/uuid (d/entity db (:db/id (:block/page b))))))))
-                  blocks*)]
+            blocks** (outliner-pipeline/build-upsert-blocks blocks* nil db)]
         (<! (p->c (persist-db/<new repo)))
         (<! (persist-db/<transact-data repo blocks** nil))
         (<! (p->c (op/<update-local-tx! repo t)))))))
@@ -125,3 +124,6 @@
               all-blocks (transit/read reader body)]
           (<! (<transact-remote-all-blocks-to-sqlite all-blocks repo))
           (<! (p->c (op/<update-graph-uuid! repo graph-uuid))))))))
+
+(comment
+  )