enhance(rtc): err handling improvements

convert several exception types into ex-info, ensuring them transit-writable/readable

Author: RCmerci

deps/db/src/logseq/db/sqlite/util.cljs

@@ -38,7 +38,9 @@
                                     ExceptionInfo (transit/write-handler (constantly "error")
                                                                          (fn [e]
                                                                            {:message (ex-message e)
-                                                                            :data (ex-data e)})))
+                                                                            :data (ex-data e)}))
+                                    js/Error (transit/write-handler (constantly "js/Error")
+                                                                    (fn [e] {:message (ex-message e)})))
                              (merge write-handlers))
         writer (transit/writer :json {:handlers write-handlers*})]
     (fn write-transit-str* [o]
@@ -51,7 +53,8 @@
 (def read-transit-str
   (let [read-handlers* (->> (assoc dt/read-handlers
                                    "datascript/Entity" identity
-                                   "error" (fn [m] (ex-info (:message m) (:data m))))
+                                   "error" (fn [m] (ex-info (:message m) (:data m)))
+                                   "js/Error" (fn [m] (js/Error. (:message m))))
                             (merge read-handlers))
         reader (transit/reader :json {:handlers read-handlers*})]
     (fn read-transit-str* [s]

src/main/frontend/common/missionary.cljs

@@ -115,20 +115,20 @@
   (m/reduce {} nil (m/eduction (take 1) f)))
 
 (defn- fail-case-default-handler
-  [e]
+  [key' e]
   (when-not (instance? Cancelled e)
-    (log/error :run-task*-failed e)))
+    (log/error :run-task-failed e :key key')))
 
 (defn run-task
   "Return the canceler"
   [key' task & {:keys [succ fail]}]
-  (let [cancel (task (or succ #(log/info :key key' :succ %)) (or fail fail-case-default-handler))]
+  (let [cancel (task (or succ #(log/info :key key' :succ %)) (or fail (partial fail-case-default-handler key')))]
     #(cancel)))
 
 (defn run-task*
   "Return the canceler"
   [task & {:keys [succ fail]}]
-  (let [cancel (task (or succ (constantly nil)) (or fail fail-case-default-handler))]
+  (let [cancel (task (or succ (constantly nil)) (or fail (partial fail-case-default-handler nil)))]
     #(cancel)))
 
 (comment

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

@@ -244,7 +244,7 @@
                       (if (= ::r.remote-update/need-pull-remote-data (:type (ex-data e)))
                         (m/? (r.client/new-task--pull-remote-data
                               repo conn graph-uuid major-schema-version date-formatter get-ws-create-task add-log-fn))
-                        (throw e))))
+                        (throw (r.ex/e->ex-info e)))))
 
                :local-update-check
                (m/? (r.client/new-task--push-local-ops
@@ -265,10 +265,10 @@
            (m/?))
           (catch Cancelled e
             (add-log-fn :rtc.log/cancelled {})
-            (throw e))
+            (throw (r.ex/e->ex-info e)))
           (catch :default e
             (add-log-fn :rtc.log/cancelled {:ex-message (ex-message e) :ex-data (ex-data e)})
-            (throw e))
+            (throw (r.ex/e->ex-info e)))
           (finally
             (started-dfv :final) ;; ensure started-dfv can recv a value(values except the first one will be disregarded)
             (when @*assets-sync-loop-canceler (@*assets-sync-loop-canceler))))))}))

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

@@ -1,6 +1,7 @@
 (ns frontend.worker.rtc.exception
   "Exception list"
-  (:require [logseq.common.defkeywords :refer [defkeywords]]))
+  (:require [logseq.common.defkeywords :refer [defkeywords]])
+  (:import [missionary Cancelled]))
 
 (defkeywords
   :rtc.exception/ws-already-disconnected {:doc "Remote exception. current websocket conn is already disconnected and deleted by remote."}
@@ -52,7 +53,17 @@ the server will put it to s3 and return its presigned-url to clients."}
   (ex-info "Unknown server error" {:type :rtc.exception/unknown-server-error}))
 
 (defn ->map
+  "TODO: deprecated
+  This function was used to map exceptions to a format suitable for posting messages to the UI thread.
+  However, ldb/write-transit-str now supports the ExceptionInfo type, making this function unnecessary."
   [e]
   (when-let [data (ex-data e)]
     {:ex-data data
      :ex-message (ex-message e)}))
+
+(defn e->ex-info
+  [e]
+  (cond
+    (instance? Cancelled e) (ex-info "missionary.Cancelled" {:message (.-message e)})
+    (instance? js/CloseEvent e) (ex-info "js/CloseEvent" {:type (.-type e)})
+    :else e))