feat(rtc,wip): check & send migrate-data when rtc-start

src/main/frontend/worker/rtc/client.cljs

@@ -12,6 +12,7 @@
             [frontend.worker.rtc.skeleton :as r.skeleton]
             [frontend.worker.rtc.ws :as ws]
             [frontend.worker.rtc.ws-util :as ws-util]
+            [logseq.db :as ldb]
             [logseq.db.frontend.schema :as db-schema]
             [missionary.core :as m]))
 
@@ -36,7 +37,8 @@
   "Return a task: get or create a mws(missionary wrapped websocket).
   see also `ws/get-mws-create`.
   But ensure `register-graph-updates` and `calibrate-graph-skeleton` has been sent"
-  [get-ws-create-task graph-uuid major-schema-version repo conn *last-calibrate-t *online-users add-log-fn]
+  [get-ws-create-task graph-uuid major-schema-version repo conn
+   *last-calibrate-t *online-users *server-schema-version add-log-fn]
   (assert (some? graph-uuid))
   (let [*sent (atom {}) ;; ws->bool
         ]
@@ -75,8 +77,10 @@
           (let [t (client-op/get-local-tx repo)]
             (when (or (nil? @*last-calibrate-t)
                       (< 500 (- t @*last-calibrate-t)))
-              ;; (m/? (r.skeleton/new-task--calibrate-graph-skeleton get-ws-create-task graph-uuid conn t))
-              (m/? (r.skeleton/new-task--calibrate-graph-skeleton get-ws-create-task graph-uuid major-schema-version @conn))
+              (let [{:keys [server-schema-version _server-builtin-db-idents]}
+                    (m/? (r.skeleton/new-task--calibrate-graph-skeleton
+                          get-ws-create-task graph-uuid major-schema-version @conn))]
+                (reset! *server-schema-version server-schema-version))
               (reset! *last-calibrate-t t)))
           (swap! *sent assoc ws true))
         ws))))
@@ -142,16 +146,14 @@
 (defn- schema-av-coll->update-schema-op
   [db block-uuid db-ident schema-av-coll]
   (when (and (seq schema-av-coll) db-ident)
-    (let [db-ident-ns (namespace db-ident)]
-      (when (and (string/ends-with? db-ident-ns ".property")
-                 (not= db-ident-ns "logseq.property"))
-        (when-let [ent (d/entity db db-ident)]
-          [:update-schema
-           (cond-> {:block-uuid block-uuid
-                    :db/ident db-ident
-                    :db/valueType (or (:db/valueType ent) :db.type/string)}
-             (:db/cardinality ent) (assoc :db/cardinality (:db/cardinality ent))
-             (:db/index ent) (assoc :db/index (:db/index ent)))])))))
+    (when-let [ent (d/entity db db-ident)]
+      (when (ldb/property? ent)
+        [:update-schema
+         (cond-> {:block-uuid block-uuid
+                  :db/ident db-ident
+                  :db/valueType (or (:db/valueType ent) :db.type/string)}
+           (:db/cardinality ent) (assoc :db/cardinality (:db/cardinality ent))
+           (:db/index ent) (assoc :db/index (:db/index ent)))]))))
 
 (defn- av-coll->card-one-attrs
   [db-schema av-coll]

src/main/frontend/worker/rtc/client_op.cljs

@@ -1,10 +1,12 @@
 (ns frontend.worker.rtc.client-op
   "Store client-ops in a persisted datascript"
   (:require [datascript.core :as d]
+            [datascript.impl.entity :as de]
             [frontend.common.missionary :as c.m]
             [frontend.worker.rtc.malli-schema :as rtc-schema]
             [frontend.worker.state :as worker-state]
             [lambdaisland.glogi :as log]
+            [logseq.db :as ldb]
             [logseq.db.sqlite.util :as sqlite-util]
             [malli.core :as ma]
             [malli.transform :as mt]
@@ -362,3 +364,18 @@
                                (d/datoms @conn :avet :block/uuid))
                        (map (fn [datom] [:db/retractEntity (:e datom)])))]
       (d/transact! conn tx-data))))
+
+(defn property-entity->ops
+  [property-entity]
+  (assert (and (de/entity? property-entity) (ldb/property? property-entity)))
+  [[:update-schema
+    (cond-> {:block-uuid (:block/uuid property-entity)
+             :db/ident (:db/ident property-entity)
+             :db/valueType (or (:db/valueType property-entity) :db.type/string)}
+      (:db/cardinality property-entity) (assoc :db/cardinality (:db/cardinality property-entity))
+      (:db/index property-entity) (assoc :db/index (:db/index property-entity)))]
+
+   [:update
+    ;; todo
+    ]
+   ])

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

@@ -188,15 +188,16 @@
         *last-calibrate-t          (atom nil)
         *online-users              (atom nil)
         *assets-sync-loop-canceler (atom nil)
+        *server-schema-version     (atom nil)
         started-dfv                (m/dfv)
         add-log-fn                 (fn [type message]
                                      (assert (map? message) message)
                                      (rtc-log-and-state/rtc-log type (assoc message :graph-uuid graph-uuid)))
         {:keys [*current-ws get-ws-create-task]}
         (gen-get-ws-create-map--memoized ws-url)
-        get-ws-create-task         (r.client/ensure-register-graph-updates
-                                    get-ws-create-task graph-uuid major-schema-version
-                                    repo conn *last-calibrate-t *online-users add-log-fn)
+        get-ws-create-task (r.client/ensure-register-graph-updates
+                            get-ws-create-task graph-uuid major-schema-version
+                            repo conn *last-calibrate-t *online-users *server-schema-version add-log-fn)
         {:keys [assets-sync-loop-task]}
         (r.asset/create-assets-sync-loop repo get-ws-create-task graph-uuid major-schema-version conn *auto-push?)
         mixed-flow                 (create-mixed-flow repo get-ws-create-task *auto-push? *online-users)]

src/main/frontend/worker/rtc/migrate.cljs

@@ -0,0 +1,29 @@
+(ns frontend.worker.rtc.migrate
+  "migrate server data according to schema-version and client's migration-updates"
+  (:require [logseq.db.frontend.schema :as db-schema]
+            [frontend.worker.db.migrate :as db-migrate]
+            [datascript.core :as d]))
+
+(defn- server-client-schema-verion->migrations
+  [server-schema-version client-schema-version]
+  (when (neg? (db-schema/compare-schema-version server-schema-version client-schema-version))
+    (let [sorted-schema-version->updates
+          (->> (map (fn [[schema-version updates]]
+                      [((juxt :major :minor) (db-schema/parse-schema-version schema-version))
+                       updates])
+                    db-migrate/schema-version->updates)
+               (sort-by first))]
+      (->> sorted-schema-version->updates
+           (drop-while (fn [[schema-version _updates]]
+                         (not (neg? (db-schema/compare-schema-version server-schema-version schema-version)))))
+           (take-while (fn [[schema-version _updates]]
+                         (not (neg? (db-schema/compare-schema-version client-schema-version schema-version)))))))))
+
+
+(defn- migration-update->client-ops
+  "TODO: support :classes in migration-updates"
+  [db migrate-update]
+  (let [new-property-entites (keep (fn [k] (d/entity db k)) (:properties migrate-update))]
+
+    )
+  )

src/main/frontend/worker/rtc/skeleton.cljs

@@ -51,4 +51,5 @@
                                            (conj [:p (str :client-only-db-idents client-only)])
                                            (seq server-only)
                                            (conj [:p (str :server-only-db-idents server-only)]))
-                                         :error]))))))))
+                                         :error])))
+          r)))))