enhance(rtc): add schema-version arg to related apis

src/main/frontend/components/repo.cljs

@@ -63,7 +63,7 @@
 (rum/defc repos-inner
   "Graph list in `All graphs` page"
   [repos]
-  (for [{:keys [root url remote? GraphUUID GraphName created-at last-seen-at] :as repo}
+  (for [{:keys [root url remote? GraphUUID GraphSchemaVersion GraphName created-at last-seen-at] :as repo}
         (sort-repos-with-metadata-local repos)
         :let [only-cloud? (and remote? (nil? root))
               db-based? (config/db-based-graph? url)]]
@@ -122,10 +122,10 @@
                                                       (when (or manager? (not db-graph?))
                                                         (let [<delete-graph (if db-graph?
                                                                               rtc-handler/<rtc-delete-graph!
-                                                                              (fn [graph-uuid]
+                                                                              (fn [graph-uuid _graph-schema-version]
                                                                                 (async-util/c->p (file-sync/<delete-graph graph-uuid))))]
                                                           (state/set-state! [:file-sync/remote-graphs :loading] true)
-                                                          (p/do! (<delete-graph GraphUUID)
+                                                          (p/do! (<delete-graph GraphUUID GraphSchemaVersion)
                                                                  (state/delete-repo! repo)
                                                                  (state/delete-remote-graph! repo)
                                                                  (state/set-state! [:file-sync/remote-graphs :loading] false)))))

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

@@ -1,6 +1,7 @@
 (ns frontend.db.rtc.debug-ui
   "Debug UI for rtc module"
   (:require [fipp.edn :as fipp]
+            [frontend.common.missionary :as c.m]
             [frontend.db :as db]
             [frontend.handler.db-based.rtc-flows :as rtc-flows]
             [frontend.handler.user :as user]
@@ -8,7 +9,6 @@
             [frontend.state :as state]
             [frontend.ui :as ui]
             [frontend.util :as util]
-            [frontend.common.missionary :as c.m]
             [logseq.db :as ldb]
             [logseq.shui.ui :as shui]
             [missionary.core :as m]
@@ -78,7 +78,9 @@
                      (map
                       #(into {}
                              (filter second
-                                     (select-keys % [:graph-uuid :graph-name
+                                     (select-keys % [:graph-uuid
+                                                     :graph-schema-version
+                                                     :graph-name
                                                      :graph-status
                                                      :graph<->user-user-type
                                                      :graph<->user-grant-by-user])))
@@ -174,14 +176,16 @@
                   :class "mr-2"
                   :on-click (fn []
                               (when-let [graph-name (:download-graph-to-repo debug-state*)]
-                                (when-let [graph-uuid (:graph-uuid-to-download debug-state*)]
+                                (when-let [{:keys [graph-uuid graph-schema-version]}
+                                           (:graph-uuid-to-download debug-state*)]
                                   (let [^object worker @db-browser/*worker]
-                                    (prn :download-graph graph-uuid :to graph-name)
+                                    (prn :download-graph graph-uuid graph-schema-version :to graph-name)
                                     (p/let [token (state/get-auth-id-token)
-                                            download-info-uuid (.rtc-request-download-graph worker token graph-uuid)
+                                            download-info-uuid (.rtc-request-download-graph
+                                                                worker token graph-uuid graph-schema-version)
                                             download-info-uuid (ldb/read-transit-str download-info-uuid)
                                             result (.rtc-wait-download-graph-info-ready
-                                                    worker token download-info-uuid graph-uuid 60000)
+                                                    worker token download-info-uuid graph-uuid graph-schema-version 60000)
                                             {:keys [_download-info-uuid
                                                     download-info-s3-url
                                                     _download-info-tx-instant
@@ -195,18 +199,20 @@
       [:b "➡"]
       [:div.flex.flex-row.items-center.gap-2
        (shui/select
-        {:on-value-change (fn [v]
-                            (some->> (parse-uuid v)
-                                     str
-                                     (swap! debug-state assoc :graph-uuid-to-download)))}
+        {:on-value-change (fn [[graph-uuid graph-schema-version]]
+                            (when (and (parse-uuid graph-uuid) graph-schema-version)
+                              (swap! debug-state assoc
+                                     :graph-uuid-to-download
+                                     {:graph-uuid graph-uuid
+                                      :graph-schema-version graph-schema-version})))}
         (shui/select-trigger
          {:class "!px-2 !py-0 !h-8 border-gray-04"}
          (shui/select-value
           {:placeholder "Select a graph-uuid"}))
         (shui/select-content
          (shui/select-group
-          (for [{:keys [graph-uuid graph-status]} (sort-by :graph-uuid (:remote-graphs debug-state*))]
-            (shui/select-item {:value graph-uuid :disabled (some? graph-status)} graph-uuid)))))
+          (for [{:keys [graph-uuid graph-schema-version graph-status]} (sort-by :graph-uuid (:remote-graphs debug-state*))]
+            (shui/select-item {:value [graph-uuid graph-schema-version] :disabled (some? graph-status)} graph-uuid)))))
 
        [:b "＋"]
        [:input.form-input.my-2.py-1
@@ -237,25 +243,27 @@
       (ui/button (str "delete graph")
                  {:icon "trash"
                   :on-click (fn []
-                              (when-let [graph-uuid (:graph-uuid-to-delete debug-state*)]
+                              (when-let [{:keys [graph-uuid graph-schema-version]} (:graph-uuid-to-delete debug-state*)]
                                 (let [token (state/get-auth-id-token)
                                       ^object worker @db-browser/*worker]
-                                  (prn ::delete-graph graph-uuid)
-                                  (.rtc-delete-graph worker token graph-uuid))))})
+                                  (prn ::delete-graph graph-uuid graph-schema-version)
+                                  (.rtc-delete-graph worker token graph-uuid graph-schema-version))))})
 
       (shui/select
-       {:on-value-change (fn [v]
-                           (some->> (parse-uuid v)
-                                    str
-                                    (swap! debug-state assoc :graph-uuid-to-delete)))}
+       {:on-value-change (fn [[graph-uuid graph-schema-version]]
+                           (when (and (parse-uuid graph-uuid) graph-schema-version)
+                             (swap! debug-state assoc
+                                    :graph-uuid-to-delete
+                                    {:graph-uuid graph-uuid
+                                     :graph-schema-version graph-schema-version})))}
        (shui/select-trigger
         {:class "!px-2 !py-0 !h-8"}
         (shui/select-value
          {:placeholder "Select a graph-uuid"}))
        (shui/select-content
         (shui/select-group
-         (for [{:keys [graph-uuid graph-status]} (:remote-graphs debug-state*)]
-           (shui/select-item {:value graph-uuid :disabled (some? graph-status)} graph-uuid)))))]
+         (for [{:keys [graph-uuid graph-schema-version graph-status]} (:remote-graphs debug-state*)]
+           (shui/select-item {:value [graph-uuid graph-schema-version] :disabled (some? graph-status)} graph-uuid)))))]
 
      [:hr.my-2]
 

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

@@ -24,12 +24,12 @@
        (.rtc-async-upload-graph worker repo token repo-name)))))
 
 (defn <rtc-delete-graph!
-  [graph-uuid]
+  [graph-uuid schema-version]
   (when-let [^js worker @state/*db-worker]
     (p/do!
      (js/Promise. user-handler/task--ensure-id&access-token)
      (let [token (state/get-auth-id-token)]
-       (.rtc-delete-graph worker token graph-uuid)))))
+       (.rtc-delete-graph worker token graph-uuid schema-version)))))
 
 (defn <rtc-download-graph!
   [graph-name graph-uuid timeout-ms]
@@ -94,6 +94,7 @@
                                  (let [url (str config/db-version-prefix (:graph-name graph))]
                                    {:url url
                                     :GraphName (:graph-name graph)
+                                    :GraphSchemaVersion (:graph-schema-version graph)
                                     :GraphUUID (:graph-uuid graph)
                                     :rtc-graph? true})
                                  (dissoc graph :graph-uuid :graph-name)))))]

src/main/frontend/worker/db_worker.cljs

@@ -811,9 +811,9 @@
      (js/Promise. (rtc-core/new-task--get-graphs token))))
 
   (rtc-delete-graph
-   [this token graph-uuid]
+   [this token graph-uuid schema-version]
    (with-write-transit-str
-     (js/Promise. (rtc-core/new-task--delete-graph token graph-uuid))))
+     (js/Promise. (rtc-core/new-task--delete-graph token graph-uuid schema-version))))
 
   (rtc-get-users-info
    [this token graph-uuid]
@@ -837,15 +837,15 @@
 
   ;; ================================================================
   (rtc-request-download-graph
-   [this token graph-uuid]
+   [this token graph-uuid schema-version]
    (with-write-transit-str
-     (js/Promise. (rtc-core/new-task--request-download-graph token graph-uuid))))
+     (js/Promise. (rtc-core/new-task--request-download-graph token graph-uuid schema-version))))
 
   (rtc-wait-download-graph-info-ready
-   [this token download-info-uuid graph-uuid timeout-ms]
+   [this token download-info-uuid graph-uuid schema-version timeout-ms]
    (with-write-transit-str
      (js/Promise.
-      (rtc-core/new-task--wait-download-info-ready token download-info-uuid graph-uuid timeout-ms))))
+      (rtc-core/new-task--wait-download-info-ready token download-info-uuid graph-uuid schema-version timeout-ms))))
 
   (rtc-download-graph-from-s3
    [this graph-uuid graph-name s3-url]
@@ -853,9 +853,9 @@
      (js/Promise. (rtc-core/new-task--download-graph-from-s3 graph-uuid graph-name s3-url))))
 
   (rtc-download-info-list
-   [this token graph-uuid]
+   [this token graph-uuid schema-version]
    (with-write-transit-str
-     (js/Promise. (rtc-core/new-task--download-info-list token graph-uuid))))
+     (js/Promise. (rtc-core/new-task--download-info-list token graph-uuid schema-version))))
 
   (rtc-get-graph-keys
    [this repo]

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

@@ -23,29 +23,30 @@
       (assert (some? major) schema-version)
       major)))
 
-(defn compare-schemas
-  "Return one of [:create-branch :download nil].
+(comment
+  (defn compare-schemas
+    "Return one of [:create-branch :download nil].
   when nil, nothing need to do"
-  [server-graph-schema app-schema client-graph-schema]
-  (let [[server-graph-schema app-schema client-graph-schema]
-        (map major-version [server-graph-schema app-schema client-graph-schema])]
-    (cond
-      (= server-graph-schema client-graph-schema)
-      nil
-
-      (> server-graph-schema client-graph-schema)
+    [server-graph-schema app-schema client-graph-schema]
+    (let [[server-graph-schema app-schema client-graph-schema]
+          (map major-version [server-graph-schema app-schema client-graph-schema])]
       (cond
-        ;; client will do some migrations on local-graph,
-        ;; so do nothing for now
-        (< server-graph-schema app-schema) nil
-        ;; client-app-schema < server-graph-schema,
-        ;; so app need to be upgraded, do nothing for now
-        (> server-graph-schema app-schema) nil
-        (= server-graph-schema app-schema) :download)
+        (= server-graph-schema client-graph-schema)
+        nil
 
-      (< server-graph-schema client-graph-schema)
-      (cond
-        ;; this remote-graph branch is creating now,
-        ;; disallow upload a new schema-version graph for now
-        (>= server-graph-schema app-schema) nil
-        (< server-graph-schema app-schema) :create-branch))))
+        (> server-graph-schema client-graph-schema)
+        (cond
+          ;; client will do some migrations on local-graph,
+          ;; so do nothing for now
+          (< server-graph-schema app-schema) nil
+          ;; client-app-schema < server-graph-schema,
+          ;; so app need to be upgraded, do nothing for now
+          (> server-graph-schema app-schema) nil
+          (= server-graph-schema app-schema) :download)
+
+        (< server-graph-schema client-graph-schema)
+        (cond
+          ;; this remote-graph branch is creating now,
+          ;; disallow upload a new schema-version graph for now
+          (>= server-graph-schema app-schema) nil
+          (< server-graph-schema app-schema) :create-branch)))))

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

@@ -20,7 +20,7 @@
       (let [{remote-t :t :as resp}
             (m/? (ws-util/send&recv get-ws-create-task {:action "register-graph-updates"
                                                         :graph-uuid graph-uuid
-                                                        :schema-version major-schema-version}))]
+                                                        :schema-version (str major-schema-version)}))]
         (rtc-log-and-state/update-remote-t graph-uuid remote-t)
         (when-not (client-op/get-local-tx repo)
           (client-op/update-local-tx repo remote-t))
@@ -70,7 +70,7 @@
             (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 @conn))
+              (m/? (r.skeleton/new-task--calibrate-graph-skeleton get-ws-create-task graph-uuid major-schema-version @conn))
               (reset! *last-calibrate-t t)))
           (swap! *sent assoc ws true))
         ws))))
@@ -333,7 +333,7 @@
 
 (defn new-task--push-local-ops
   "Return a task: push local updates"
-  [repo conn graph-uuid date-formatter get-ws-create-task *remote-profile? add-log-fn]
+  [repo conn graph-uuid major-schema-version date-formatter get-ws-create-task *remote-profile? add-log-fn]
   (m/sp
     (let [block-ops-map-coll (client-op/get&remove-all-block-ops repo)]
       (when-let [block-uuid->remote-ops (not-empty (gen-block-uuid->remote-ops @conn block-ops-map-coll))]
@@ -343,7 +343,8 @@
           (let [local-tx (client-op/get-local-tx repo)
                 r (try
                     (m/? (ws-util/send&recv get-ws-create-task
-                                            (cond-> {:action "apply-ops" :graph-uuid graph-uuid
+                                            (cond-> {:action "apply-ops"
+                                                     :graph-uuid graph-uuid :schema-version (str major-schema-version)
                                                      :ops ops-for-remote :t-before (or local-tx 1)}
                                               (true? @*remote-profile?) (assoc :profile true))))
                     (catch :default e
@@ -376,10 +377,11 @@
                   (add-log-fn :rtc.log/push-local-update {:remote-t (:t r)})))))))))
 
 (defn new-task--pull-remote-data
-  [repo conn graph-uuid date-formatter get-ws-create-task add-log-fn]
+  [repo conn graph-uuid major-schema-version date-formatter get-ws-create-task add-log-fn]
   (m/sp
     (let [local-tx (client-op/get-local-tx repo)
-          r (m/? (ws-util/send&recv get-ws-create-task {:action "apply-ops" :graph-uuid graph-uuid
+          r (m/? (ws-util/send&recv get-ws-create-task {:action "apply-ops"
+                                                        :graph-uuid graph-uuid :schema-version (str major-schema-version)
                                                         :ops [] :t-before (or local-tx 1)}))]
       (if-let [remote-ex (:ex-data r)]
         (do (add-log-fn :rtc.log/push-local-update (assoc remote-ex :sub-type :pull-remote-data))

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

@@ -223,14 +223,14 @@
                     (catch :default e
                       (when (= ::r.remote-update/need-pull-remote-data (:type (ex-data e)))
                         (m/? (r.client/new-task--pull-remote-data
-                              repo conn graph-uuid date-formatter get-ws-create-task add-log-fn)))))
+                              repo conn graph-uuid major-schema-version date-formatter get-ws-create-task add-log-fn)))))
                :remote-asset-update
                (m/? (r.asset/new-task--emit-remote-asset-updates-from-push-asset-upload-updates
                      repo @conn (:value event)))
 
                :local-update-check
                (m/? (r.client/new-task--push-local-ops
-                     repo conn graph-uuid date-formatter
+                     repo conn graph-uuid major-schema-version date-formatter
                      get-ws-create-task *remote-profile? add-log-fn))
 
                :online-users-updated
@@ -238,10 +238,10 @@
 
                :pull-remote-updates
                (m/? (r.client/new-task--pull-remote-data
-                     repo conn graph-uuid date-formatter get-ws-create-task add-log-fn))
+                     repo conn graph-uuid major-schema-version date-formatter get-ws-create-task add-log-fn))
 
                :inject-users-info
-               (m/? (new-task--inject-users-info token graph-uuid))))
+               (m/? (new-task--inject-users-info token graph-uuid major-schema-version))))
            (m/ap)
            (m/reduce {} nil)
            (m/?))
@@ -360,12 +360,14 @@
 
 (defn new-task--delete-graph
   "Return a task that return true if succeed"
-  [token graph-uuid]
+  [token graph-uuid schema-version]
   (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (m/sp
       (let [{:keys [ex-data]}
             (m/? (ws-util/send&recv get-ws-create-task
-                                    {:action "delete-graph" :graph-uuid graph-uuid}))]
+                                    {:action "delete-graph"
+                                     :graph-uuid graph-uuid
+                                     :schema-version (str schema-version)}))]
         (when ex-data (prn ::delete-graph-failed graph-uuid ex-data))
         (boolean (nil? ex-data))))))
 
@@ -378,10 +380,12 @@
                                {:action "get-users-info" :graph-uuid graph-uuid}))))
 
 (defn new-task--inject-users-info
-  [token graph-uuid]
+  [token graph-uuid major-schema-version]
   (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (ws-util/send&recv get-ws-create-task
-                       {:action "inject-users-info" :graph-uuid graph-uuid})))
+                       {:action "inject-users-info"
+                        :graph-uuid graph-uuid
+                        :schema-version (str major-schema-version)})))
 
 (defn new-task--grant-access-to-others
   [token graph-uuid & {:keys [target-user-uuids target-user-emails]}]
@@ -443,26 +447,29 @@
   [token repo remote-graph-name]
   (m/sp
     (if-let [conn (worker-state/get-datascript-conn repo)]
-      (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
-        (m/? (r.upload-download/new-task--upload-graph get-ws-create-task repo conn remote-graph-name)))
+      (let [schema-version (ldb/get-graph-schema-version @conn)
+            major-schema-version (r.branch-graph/major-version schema-version)
+            {:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
+        (m/? (r.upload-download/new-task--upload-graph
+              get-ws-create-task repo conn remote-graph-name major-schema-version)))
       (r.ex/->map (ex-info "Not found db-conn" {:type :rtc.exception/not-found-db-conn
                                                 :repo repo})))))
 
 (defn new-task--request-download-graph
-  [token graph-uuid]
+  [token graph-uuid schema-version]
   (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
-    (r.upload-download/new-task--request-download-graph get-ws-create-task graph-uuid)))
+    (r.upload-download/new-task--request-download-graph get-ws-create-task graph-uuid schema-version)))
 
 (defn new-task--download-info-list
-  [token graph-uuid]
+  [token graph-uuid schema-version]
   (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
-    (r.upload-download/new-task--download-info-list get-ws-create-task graph-uuid)))
+    (r.upload-download/new-task--download-info-list get-ws-create-task graph-uuid schema-version)))
 
 (defn new-task--wait-download-info-ready
-  [token download-info-uuid graph-uuid timeout-ms]
+  [token download-info-uuid graph-uuid schema-version timeout-ms]
   (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (r.upload-download/new-task--wait-download-info-ready
-     get-ws-create-task download-info-uuid graph-uuid timeout-ms)))
+     get-ws-create-task download-info-uuid graph-uuid schema-version timeout-ms)))
 
 (def new-task--download-graph-from-s3 r.upload-download/new-task--download-graph-from-s3)
 

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

@@ -118,7 +118,7 @@
                   (:block/order block) (update :block/order ldb/read-transit-str)))))))
 
 (defn new-task--upload-graph
-  [get-ws-create-task repo conn remote-graph-name]
+  [get-ws-create-task repo conn remote-graph-name major-schema-version]
   (m/sp
     (rtc-log-and-state/rtc-log :rtc.log/upload {:sub-type :fetch-presigned-put-url
                                                 :message "fetching presigned put-url"})
@@ -143,6 +143,7 @@
             upload-resp
             (m/? (ws-util/send&recv get-ws-create-task {:action "upload-graph"
                                                         :s3-key key
+                                                        :schema-version (str major-schema-version)
                                                         :graph-name remote-graph-name}))]
         (if-let [graph-uuid (:graph-uuid upload-resp)]
           (do
@@ -354,22 +355,25 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defn new-task--request-download-graph
-  [get-ws-create-task graph-uuid]
+  [get-ws-create-task graph-uuid schema-version]
   (rtc-log-and-state/rtc-log :rtc.log/download {:sub-type :request-download-graph
                                                 :message "requesting download graph"
-                                                :graph-uuid graph-uuid})
+                                                :graph-uuid graph-uuid
+                                                :schema-version schema-version})
   (m/join :download-info-uuid
           (ws-util/send&recv get-ws-create-task {:action "download-graph"
-                                                 :graph-uuid graph-uuid})))
+                                                 :graph-uuid graph-uuid
+                                                 :schema-version (str schema-version)})))
 
 (defn new-task--download-info-list
-  [get-ws-create-task graph-uuid]
+  [get-ws-create-task graph-uuid schema-version]
   (m/join :download-info-list
           (ws-util/send&recv get-ws-create-task {:action "download-info-list"
-                                                 :graph-uuid graph-uuid})))
+                                                 :graph-uuid graph-uuid
+                                                 :schema-version (str schema-version)})))
 
 (defn new-task--wait-download-info-ready
-  [get-ws-create-task download-info-uuid graph-uuid timeout-ms]
+  [get-ws-create-task download-info-uuid graph-uuid schema-version timeout-ms]
   (->
    (m/sp
      (rtc-log-and-state/rtc-log :rtc.log/download {:sub-type :wait-remote-graph-data-ready
@@ -379,7 +383,8 @@
        (m/? (m/sleep 3000))
        (let [{:keys [download-info-list]}
              (m/? (ws-util/send&recv get-ws-create-task {:action "download-info-list"
-                                                         :graph-uuid graph-uuid}))]
+                                                         :graph-uuid graph-uuid
+                                                         :schema-version (str schema-version)}))]
          (if-let [found-download-info
                   (some
                    (fn [download-info]

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

@@ -18,11 +18,12 @@
        db))
 
 (defn new-task--calibrate-graph-skeleton
-  [get-ws-create-task graph-uuid db]
+  [get-ws-create-task graph-uuid major-schema-version db]
   (m/sp
     (let [r (m/? (ws-util/send&recv get-ws-create-task
                                     {:action "get-graph-skeleton"
-                                     :graph-uuid graph-uuid}))]
+                                     :graph-uuid graph-uuid
+                                     :schema-version (str major-schema-version)}))]
       (if-let [remote-ex (:ex-data r)]
         (case (:type remote-ex)
           :graph-lock-failed

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

@@ -26,7 +26,7 @@
   (m/sp
     (let [decoded-message (rtc-schema/data-to-ws-coercer (assoc message :req-id "temp-id"))
           message-str (js/JSON.stringify (clj->js (select-keys (rtc-schema/data-to-ws-encoder decoded-message)
-                                                               ["graph-uuid" "ops" "t-before"])))
+                                                               ["graph-uuid" "ops" "t-before" "schema-version"])))
           len (.-length (utf8/encode message-str))]
       (when (< 100000 len)
         (let [{:keys [url key]} (m/? (ws/send&recv ws {:action "presign-put-temp-s3-obj"}))

src/rtc_e2e_test/fixture.cljs

@@ -10,6 +10,13 @@
             [frontend.common.missionary :as c.m]
             [missionary.core :as m]))
 
+(def graph-schema-version "0")
+
+(defn- transact-graph-schema-version
+  [conn]
+  (d/transact! conn [{:db/ident :logseq.kv/schema-version
+                      :kv/value graph-schema-version}]))
+
 (def install-some-consts
   {:before
    (fn []
@@ -21,6 +28,7 @@
      (prn :test-repo const/test-repo)
      (swap! worker-state/*client-ops-conns assoc const/test-repo (d/create-conn client-op/schema-in-db))
      (let [conn (d/conn-from-db example/example-db)]
+       (transact-graph-schema-version conn)
        (swap! worker-state/*datascript-conns assoc const/test-repo conn)))
    :after
    (fn []

src/rtc_e2e_test/helper.cljs

@@ -3,6 +3,7 @@
             [const]
             [datascript.core :as d]
             [datascript.transit :as dt]
+            [fixture]
             [frontend.common.missionary :as c.m]
             [frontend.worker.rtc.client-op :as client-op]
             [frontend.worker.rtc.core :as rtc.core]
@@ -41,7 +42,7 @@
                                 (not= "deleting" (:graph-status graph)))
                               graphs)]
       (doseq [graph test-graphs]
-        (m/? (rtc.core/new-task--delete-graph const/test-token (:graph-uuid graph)))
+        (m/? (rtc.core/new-task--delete-graph const/test-token (:graph-uuid graph) fixture/graph-schema-version))
         (log :deleted-graph (:graph-name graph) (:graph-uuid graph))))))
 
 (def new-task--get-remote-example-graph-uuid
@@ -69,8 +70,10 @@
 (defn new-task--download-graph
   [graph-uuid graph-name]
   (m/sp
-    (let [download-info-uuid (m/? (rtc.core/new-task--request-download-graph const/test-token graph-uuid))
-          result (m/? (rtc.core/new-task--wait-download-info-ready const/test-token download-info-uuid graph-uuid 60000))
+    (let [download-info-uuid (m/? (rtc.core/new-task--request-download-graph
+                                   const/test-token graph-uuid fixture/graph-schema-version))
+          result (m/? (rtc.core/new-task--wait-download-info-ready
+                       const/test-token download-info-uuid graph-uuid fixture/graph-schema-version 60000))
           {:keys [_download-info-uuid
                   download-info-s3-url
                   _download-info-tx-instant
@@ -91,11 +94,11 @@
   #_:clj-kondo/ignore
   (me/find
    client-op
-   [?op-type _ {:block-uuid ?block-uuid :av-coll [[!a !v _ !add] ...]}]
-   [?op-type ?block-uuid (map vector !a !v !add)]
+    [?op-type _ {:block-uuid ?block-uuid :av-coll [[!a !v _ !add] ...]}]
+    [?op-type ?block-uuid (map vector !a !v !add)]
 
-   [?op-type _ {:block-uuid ?block-uuid}]
-   [?op-type ?block-uuid]))
+    [?op-type _ {:block-uuid ?block-uuid}]
+    [?op-type ?block-uuid]))
 
 (defn new-task--wait-all-client-ops-sent
   [& {:keys [timeout] :or {timeout 10000}}]