able to download remote graph

src/main/frontend/components/repo.cljs

@@ -138,7 +138,9 @@
                                    (rtc-handler/<get-remote-graphs)))))))}
               "Use Logseq sync (Beta testing)"))
 
-           (when (and remote? manager?)
+           (when (and remote?
+                      ;; manager?
+                      )
              (shui/dropdown-menu-item
               {:key "delete-remotely"
                :class "delete-remote-graph-menu-item"

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

@@ -18,7 +18,9 @@
     (rtc-handler/<rtc-delete-graph! graph-uuid schema-version)))
 
 (defn <rtc-download-graph! [graph-name graph-uuid graph-schema-version timeout-ms]
-  (rtc-handler/<rtc-download-graph! graph-name graph-uuid graph-schema-version timeout-ms))
+  (if (worker-sync-enabled?)
+    (worker-sync-handler/<rtc-download-graph! graph-name graph-uuid graph-schema-version timeout-ms)
+    (rtc-handler/<rtc-download-graph! graph-name graph-uuid graph-schema-version timeout-ms)))
 
 (defn <rtc-stop! []
   (if (worker-sync-enabled?)

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

@@ -1,6 +1,7 @@
 (ns frontend.handler.db-based.worker-sync
   "Worker-sync handler based on Cloudflare Durable Objects."
   (:require [clojure.string :as string]
+            [datascript.core :as d]
             [frontend.config :as config]
             [frontend.db :as db]
             [frontend.handler.repo :as repo-handler]
@@ -72,7 +73,7 @@
                                   :headers {"content-type" "application/json"}
                                   :body (js/JSON.stringify
                                          #js {:graph_id (str graph-id)
-                                              :graph_name repo
+                                              :graph_name (string/replace repo config/db-version-prefix "")
                                               :schema_version schema-version})})]
         (ldb/transact! repo [(sqlite-util/kv :logseq.kv/db-type "db")
                              (sqlite-util/kv :logseq.kv/graph-uuid graph-id)])
@@ -92,6 +93,30 @@
                             :graph-uuid graph-uuid
                             :base base})))))
 
+(defn <rtc-download-graph!
+  [graph-name graph-uuid _graph-schema-version timeout-ms]
+  (state/set-state! :rtc/downloading-graph-uuid graph-uuid)
+  (let [base (http-base)]
+    (-> (if (and graph-uuid base)
+          (p/let [resp (fetch-json (str base "/sync/" graph-uuid "/snapshot")
+                                   {:method "GET"})
+                  datoms-str (aget resp "datoms")
+                  datoms (->> (ldb/read-transit-str datoms-str)
+                              (map (fn [{:keys [e a v t]}]
+                                     (d/datom e a v t true))))
+                  graph (str config/db-version-prefix graph-name)]
+            (state/<invoke-db-worker :thread-api/worker-sync-reset-from-datoms graph datoms))
+          (p/rejected (ex-info "worker-sync missing graph info"
+                               {:type :worker-sync/invalid-graph
+                                :graph-uuid graph-uuid
+                                :base base})))
+        (p/catch (fn [error]
+                   (throw error)))
+        (p/timeout timeout-ms)
+        (p/finally
+          (fn []
+            (state/set-state! :rtc/downloading-graph-uuid nil))))))
+
 (defn <get-remote-graphs
   []
   (let [base (http-base)]
@@ -102,8 +127,8 @@
                   graphs (js->clj (aget resp "graphs") :keywordize-keys true)
                   result (mapv (fn [graph]
                                  (merge
-                                  {:url (:graph_name graph)
-                                   :GraphName (string/replace (:graph_name graph) config/db-version-prefix "")
+                                  {:url (str config/db-version-prefix (:graph_name graph))
+                                   :GraphName (:graph_name graph)
                                    :GraphSchemaVersion (:schema_version graph)
                                    :GraphUUID (:graph_id graph)
                                    :rtc-graph? true}

src/main/frontend/worker/db_worker.cljs

@@ -50,6 +50,7 @@
             [logseq.db.common.view :as db-view]
             [logseq.db.frontend.class :as db-class]
             [logseq.db.frontend.property :as db-property]
+            [logseq.db.frontend.schema :as db-schema]
             [logseq.db.sqlite.create-graph :as sqlite-create-graph]
             [logseq.db.sqlite.export :as sqlite-export]
             [logseq.db.sqlite.gc :as sqlite-gc]
@@ -191,6 +192,16 @@
       (d/reset-conn! conn new-db' {:reset-conn! true})
       (d/reset-schema! conn (:schema new-db)))))
 
+(defn reset-db-from-datoms!
+  [repo datoms]
+  (p/do!
+   ((@thread-api/*thread-apis :thread-api/create-or-open-db) repo
+                                                             {:close-other-db? false
+                                                              :datoms datoms
+                                                              :worker-sync-download-graph? true})
+   ((@thread-api/*thread-apis :thread-api/export-db) repo)
+   (shared-service/broadcast-to-clients! :add-repo {:repo repo})))
+
 (defn- get-dbs
   [repo]
   (if @*publishing?
@@ -230,7 +241,7 @@
                                        :kv/value (common-util/time-ms)}]))))
 
 (defn- <create-or-open-db!
-  [repo {:keys [config datoms] :as opts}]
+  [repo {:keys [config datoms worker-sync-download-graph?] :as opts}]
   (when-not (worker-state/get-sqlite-conn repo)
     (p/let [[db search-db client-ops-db debug-log-db :as dbs] (get-dbs repo)
             storage (new-sqlite-storage db)
@@ -565,6 +576,11 @@
   (reset-db! repo db-transit)
   nil)
 
+(def-thread-api :thread-api/worker-sync-reset-from-datoms
+  [repo datoms]
+  (reset-db-from-datoms! repo datoms)
+  nil)
+
 (def-thread-api :thread-api/unsafe-unlink-db
   [repo]
   (p/let [pool (<get-opfs-pool repo)

src/main/frontend/worker/worker_sync.cljs

@@ -307,7 +307,6 @@
         db (some-> conn deref)]
     (when db
       (let [normalized (normalize-tx-data db-after db-before tx-data)
-            _ (prn :debug :normalized normalized)
             tx-str (sqlite-util/write-transit-str normalized)]
         (persist-local-tx! repo tx-str)
         (when-let [client (get @worker-state/*worker-sync-clients repo)]