enhance(rtc,crypt): rename gen-get-ws-create-map

src/main/frontend/worker/device.cljs

@@ -37,39 +37,43 @@
 (defonce *device-public-key (atom nil :validator #(instance? js/CryptoKey %)))
 (defonce *device-private-key (atom nil :validator #(instance? js/CryptoKey %)))
 
-(defn new-task--get-user-devices
+(defn- new-task--get-user-devices
   [get-ws-create-task]
   (m/join :devices (ws-util/send&recv get-ws-create-task {:action "get-user-devices"})))
 
-(defn new-task--add-user-device
+(defn- new-task--add-user-device
   [get-ws-create-task device-name]
   (m/join :device (ws-util/send&recv get-ws-create-task {:action "add-user-device"
                                                          :device-name device-name})))
 
-(defn new-task--remove-user-device
+(defn- new-task--remove-user-device
   [get-ws-create-task device-uuid]
   (ws-util/send&recv get-ws-create-task {:action "remove-user-device"
                                          :device-uuid device-uuid}))
 
-(defn new-task--update-user-device-name
+(defn- new-task--update-user-device-name
   [get-ws-create-task device-uuid device-name]
   (ws-util/send&recv get-ws-create-task {:action "update-user-device-name"
                                          :device-uuid device-uuid
                                          :device-name device-name}))
 
-(defn new-task--add-device-public-key
+(defn- new-task--add-device-public-key
   [get-ws-create-task device-uuid key-name public-key-jwk]
   (ws-util/send&recv get-ws-create-task {:action "add-device-public-key"
                                          :device-uuid device-uuid
                                          :key-name key-name
                                          :public-key (ldb/write-transit-str public-key-jwk)}))
 
-(defn new-task--remove-device-public-key
+(defn- new-task--remove-device-public-key
   [get-ws-create-task device-uuid key-name]
   (ws-util/send&recv get-ws-create-task {:action "remove-device-public-key"
                                          :device-uuid device-uuid
                                          :key-name key-name}))
 
+(defn- new-get-ws-create-task
+  [token]
+  (:get-ws-create-task (ws-util/gen-get-ws-create-map--memoized (ws-util/get-ws-url token))))
+
 (defn new-task--ensure-device-metadata!
   "Generate new device items if not exists.
   Store in indexeddb.
@@ -78,8 +82,7 @@
   (m/sp
     (let [device-uuid (c.m/<? (<get-item item-key-device-id))]
       (when-not device-uuid
-        (let [{:keys [get-ws-create-task]}
-              (ws-util/new-task--get-ws-create--memoized (ws-util/get-ws-url token))
+        (let [get-ws-create-task (new-get-ws-create-task token)
               agent-data (js->clj (.toJSON js/navigator.userAgentData) :keywordize-keys true)
               generated-device-name (string/join
                                      "-"
@@ -100,13 +103,24 @@
           (c.m/<? (<set-item! item-key-device-private-key-jwk private-key-jwk))
           (m/? (new-task--add-device-public-key
                 get-ws-create-task device-id "default-public-key" public-key-jwk))))
-      (p/let [device-uuid-str (<get-item item-key-device-id)
-              device-name (<get-item item-key-device-name)
-              device-public-key-jwk (<get-item item-key-device-public-key-jwk)
-              device-public-key (crypt/<import-public-key device-public-key-jwk)
-              device-private-key-jwk (<get-item item-key-device-private-key-jwk)
-              device-private-key (crypt/<import-private-key device-private-key-jwk)]
-        (reset! *device-id (uuid device-uuid-str))
-        (reset! *device-name device-name)
-        (reset! *device-public-key device-public-key)
-        (reset! *device-private-key device-private-key)))))
+      (c.m/<?
+       (p/let [device-uuid-str (<get-item item-key-device-id)
+               device-name (<get-item item-key-device-name)
+               device-public-key-jwk (<get-item item-key-device-public-key-jwk)
+               device-public-key (crypt/<import-public-key device-public-key-jwk)
+               device-private-key-jwk (<get-item item-key-device-private-key-jwk)
+               device-private-key (crypt/<import-private-key device-private-key-jwk)]
+         (reset! *device-id (uuid device-uuid-str))
+         (reset! *device-name device-name)
+         (reset! *device-public-key device-public-key)
+         (reset! *device-private-key device-private-key))))))
+
+(defn new-task--list-devices
+  "Return device list.
+  Also sync local device metadata to remote if not exists in remote side"
+  [token]
+  (m/sp
+    (let [get-ws-create-task (new-get-ws-create-task token)
+          devices (m/? (new-task--get-user-devices get-ws-create-task))]
+      (prn :debug-devices devices)
+      devices)))

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

@@ -10,7 +10,7 @@
             [frontend.worker.rtc.remote-update :as r.remote-update]
             [frontend.worker.rtc.skeleton]
             [frontend.worker.rtc.ws :as ws]
-            [frontend.worker.rtc.ws-util :as ws-util :refer [new-task--get-ws-create--memoized]]
+            [frontend.worker.rtc.ws-util :as ws-util :refer [gen-get-ws-create-map--memoized]]
             [frontend.worker.state :as worker-state]
             [frontend.worker.util :as worker-util]
             [logseq.common.config :as common-config]
@@ -146,7 +146,7 @@
                                      (assert (map? message) message)
                                      (rtc-log-and-state/rtc-log type (assoc message :graph-uuid graph-uuid)))
         {:keys [*current-ws get-ws-create-task]}
-        (new-task--get-ws-create--memoized ws-url)
+        (gen-get-ws-create-map--memoized ws-url)
         get-ws-create-task         (r.client/ensure-register-graph-updates
                                     get-ws-create-task graph-uuid repo conn *last-calibrate-t *online-users)
         {:keys [assets-sync-loop-task]}
@@ -250,14 +250,14 @@
 
 (defn new-task--get-graphs
   [token]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (m/join :graphs
             (ws-util/send&recv get-ws-create-task {:action "list-graphs"}))))
 
 (defn new-task--delete-graph
   "Return a task that return true if succeed"
   [token graph-uuid]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (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
@@ -268,14 +268,14 @@
 (defn new-task--get-user-info
   "Return a task that return users-info about the graph."
   [token graph-uuid]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (m/join :users
             (ws-util/send&recv get-ws-create-task
                                {:action "get-users-info" :graph-uuid graph-uuid}))))
 
 (defn new-task--grant-access-to-others
   [token graph-uuid & {:keys [target-user-uuids target-user-emails]}]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (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
                        (cond-> {:action "grant-access"
                                 :graph-uuid graph-uuid}
@@ -285,7 +285,7 @@
 (defn new-task--get-block-content-versions
   "Return a task that return map [:ex-data :ex-message :versions]"
   [token graph-uuid block-uuid]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (m/join :versions (ws-util/send&recv get-ws-create-task
                                          {:action "query-block-content-versions"
                                           :block-uuids [block-uuid]
@@ -322,13 +322,13 @@
 
 (defn new-task--snapshot-graph
   [token graph-uuid]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (m/join #(select-keys % [:snapshot-uuid :graph-uuid])
             (ws-util/send&recv get-ws-create-task {:action "snapshot-graph"
                                                    :graph-uuid graph-uuid}))))
 (defn new-task--snapshot-list
   [token graph-uuid]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (let [{:keys [get-ws-create-task]} (gen-get-ws-create-map--memoized (ws-util/get-ws-url token))]
     (m/join :snapshot-list
             (ws-util/send&recv get-ws-create-task {:action "snapshot-list"
                                                    :graph-uuid graph-uuid}))))
@@ -337,24 +337,24 @@
   [token repo remote-graph-name]
   (m/sp
     (if-let [conn (worker-state/get-datascript-conn repo)]
-      (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+      (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)))
       (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]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (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)))
 
 (defn new-task--download-info-list
   [token graph-uuid]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (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)))
 
 (defn new-task--wait-download-info-ready
   [token download-info-uuid graph-uuid timeout-ms]
-  (let [{:keys [get-ws-create-task]} (new-task--get-ws-create--memoized (ws-util/get-ws-url token))]
+  (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)))
 

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

@@ -60,7 +60,7 @@
   [token]
   (gstring/format @worker-state/*rtc-ws-url token))
 
-(defn- new-task--get-ws-create
+(defn- gen-get-ws-create-map
   "Return a map with atom *current-ws and a task
   that get current ws, create one if needed(closed or not created yet)"
   [url & {:keys [retry-count open-ws-timeout]
@@ -78,6 +78,6 @@
              (reset! *current-ws ws)
              ws))))}))
 
-(def new-task--get-ws-create--memoized
+(def gen-get-ws-create-map--memoized
   "Return a memoized task to reuse the same websocket."
-  (memoize new-task--get-ws-create))
+  (memoize gen-get-ws-create-map))