fix: don't run sync for local graphs that's detached from server

deps/db-sync/src/logseq/db_sync/worker/handler/index.cljs

@@ -223,9 +223,7 @@
           (if (not access?)
             (http/forbidden)
             (p/let [encrypted-aes-key (index/<graph-encrypted-aes-key db graph-id user-id)]
-              (if (some? encrypted-aes-key)
-                (http/json-response :e2ee/graph-aes-key {:encrypted-aes-key encrypted-aes-key})
-                (http/error-response "encrypted aes key missing" 404))))))
+              (http/json-response :e2ee/graph-aes-key {:encrypted-aes-key encrypted-aes-key})))))
 
       :e2ee/graph-aes-key-post
       (cond

deps/db-sync/test/logseq/db_sync/worker_handler_e2ee_test.cljs

@@ -1,28 +0,0 @@
-(ns logseq.db-sync.worker-handler-e2ee-test
-  (:require [cljs.test :refer [deftest is async]]
-            [logseq.db-sync.index :as index]
-            [logseq.db-sync.worker.handler.index :as handler]
-            [logseq.db-sync.worker.routes.index :as routes]
-            [promesa.core :as p]))
-
-(deftest graph-aes-key-get-missing-key-returns-404-test
-  (async done
-         (let [route (routes/match-route "GET" "/e2ee/graphs/graph-1/aes-key")
-               claims #js {"sub" "user-1"}]
-           (-> (p/with-redefs [index/<user-has-access-to-graph? (fn [_db _graph-id _user-id]
-                                                                  (p/resolved true))
-                               index/<graph-encrypted-aes-key (fn [_db _graph-id _user-id]
-                                                                (p/resolved nil))]
-                 (p/let [resp (handler/handle {:db :fake
-                                               :request nil
-                                               :claims claims
-                                               :route route})
-                         status (.-status resp)
-                         text (.text resp)
-                         body (when (seq text)
-                                (js->clj (js/JSON.parse text) :keywordize-keys true))]
-                   (is (= 404 status))
-                   (is (= "encrypted aes key missing" (:error body)))))
-               (p/catch (fn [e]
-                          (is false (str e))))
-               (p/finally (fn [] (done)))))))

src/main/frontend/components/header.cljs

@@ -421,7 +421,8 @@
        (when (and current-repo
                   (ldb/get-graph-rtc-uuid (db/get-db))
                   (user-handler/logged-in?)
-                  (user-handler/rtc-group?))
+                  (user-handler/rtc-group?)
+                  (some #(= current-repo (:url %)) (state/get-rtc-graphs)))
          [:<>
           (recent-slider)
           (rum/with-key (rtc-collaborators)

src/main/frontend/components/repo.cljs

@@ -150,13 +150,12 @@
                                     [:small "⚠️ Notice that we can't recover this graph after being deleted. Make sure you have backups before deleting it."]]])
                                  (p/then
                                   (fn []
-                                    (let [<delete-graph rtc-handler/<rtc-delete-graph!]
-                                      (state/set-state! :rtc/loading-graphs? true)
-                                      (when (= (state/get-current-repo) repo)
-                                        (state/<invoke-db-worker :thread-api/rtc-stop))
-                                      (p/do! (<delete-graph GraphUUID GraphSchemaVersion)
-                                             (state/set-state! :rtc/loading-graphs? false)
-                                             (rtc-handler/<get-remote-graphs))))))))}
+                                    (state/set-state! :rtc/loading-graphs? true)
+                                    (when (= (state/get-current-repo) repo)
+                                      (state/<invoke-db-worker :thread-api/rtc-stop))
+                                    (p/do! (rtc-handler/<rtc-delete-graph! GraphUUID GraphSchemaVersion)
+                                           (state/set-state! :rtc/loading-graphs? false)
+                                           (rtc-handler/<get-remote-graphs)))))))}
               "Delete from server"))
 
            (when (and remote? (not manager?))

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

@@ -147,10 +147,19 @@
         coerced))
     body))
 
+(defn- graph-in-remote-list?
+  [repo]
+  (some #(= repo (:url %)) (state/get-rtc-graphs)))
+
 (defn <rtc-start!
   [repo & {:keys [_stop-before-start?] :as _opts}]
-  (log/info :db-sync/start {:repo repo})
-  (state/<invoke-db-worker :thread-api/db-sync-start repo))
+  (if (graph-in-remote-list? repo)
+    (do
+      (log/info :db-sync/start {:repo repo})
+      (state/<invoke-db-worker :thread-api/db-sync-start repo))
+    (do
+      (log/info :db-sync/skip-start {:repo repo :reason :graph-not-in-remote-list})
+      (p/resolved nil))))
 
 (defn <rtc-stop!
   []

src/test/frontend/handler/db_based/sync_test.cljs

@@ -2,6 +2,7 @@
   (:require [cljs.test :refer [deftest is async]]
             [frontend.handler.db-based.sync :as db-sync]
             [frontend.handler.user :as user-handler]
+            [frontend.state :as state]
             [promesa.core :as p]))
 
 (deftest remove-member-request-test
@@ -51,3 +52,33 @@
              (p/catch (fn [e]
                         (is (= :db-sync/invalid-member (:type (ex-data e))))
                         (done))))))
+
+(deftest rtc-start-skips-when-graph-missing-from-remote-list-test
+  (async done
+         (let [called (atom nil)]
+           (-> (p/with-redefs [state/get-rtc-graphs (fn [] [{:url "repo-other"}])
+                               state/<invoke-db-worker (fn [& args]
+                                                         (reset! called args)
+                                                         (p/resolved :ok))]
+                 (db-sync/<rtc-start! "repo-current"))
+               (p/then (fn [_]
+                         (is (nil? @called))
+                         (done)))
+               (p/catch (fn [e]
+                          (is false (str e))
+                          (done)))))))
+
+(deftest rtc-start-invokes-worker-when-graph-in-remote-list-test
+  (async done
+         (let [called (atom nil)]
+           (-> (p/with-redefs [state/get-rtc-graphs (fn [] [{:url "repo-current"}])
+                               state/<invoke-db-worker (fn [& args]
+                                                         (reset! called args)
+                                                         (p/resolved :ok))]
+                 (db-sync/<rtc-start! "repo-current"))
+               (p/then (fn [_]
+                         (is (= [:thread-api/db-sync-start "repo-current"] @called))
+                         (done)))
+               (p/catch (fn [e]
+                          (is false (str e))
+                          (done)))))))