fix: asset op

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

@@ -223,9 +223,9 @@
           (if (not access?)
             (http/forbidden)
             (p/let [encrypted-aes-key (index/<graph-encrypted-aes-key db graph-id user-id)]
-              (http/json-response :e2ee/graph-aes-key (cond-> {}
-                                                        (some? encrypted-aes-key)
-                                                        (assoc :encrypted-aes-key encrypted-aes-key)))))))
+              (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))))))
 
       :e2ee/graph-aes-key-post
       (cond

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

@@ -0,0 +1,28 @@
+(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/worker/sync/asset_db_listener.cljs

@@ -5,37 +5,30 @@
             [frontend.worker.sync.client-op :as client-op]
             [logseq.db :as ldb]))
 
-(defn- max-t
-  [entity-datoms]
-  (apply max (map (fn [[_e _a _v t]] t) entity-datoms)))
+(defn- asset-checksum?
+  [a]
+  (= :logseq.property.asset/checksum a))
 
-(defn- asset-related-attrs-changed?
-  [entity-datoms]
-  (some (fn [[_e a]] (= :logseq.property.asset/checksum a)) entity-datoms))
-
-(defn- entity-datoms=>ops
-  [db-before db-after entity-datoms]
-  (when-let [e (ffirst entity-datoms)]
-    (let [ent-after (d/entity db-after e)
-          ent-before (d/entity db-before e)]
-      (cond
-        (and (some-> ent-after ldb/asset?)
-             (asset-related-attrs-changed? entity-datoms))
-        [[:update-asset (max-t entity-datoms) {:block-uuid (:block/uuid ent-after)}]]
-
-        (and (some-> ent-before ldb/asset?)
-             (nil? ent-after))
-        [[:remove-asset (max-t entity-datoms) {:block-uuid (:block/uuid ent-before)}]]))))
+(defn- datom=>op
+  [db-after [e _a _v t _]]
+  (let [ent-after (d/entity db-after e)]
+    (when (ldb/asset? ent-after)
+      [:update-asset t {:block-uuid (:block/uuid ent-after)}])))
 
 (defn generate-asset-ops
-  [repo db-before db-after same-entity-datoms-coll]
-  (when-let [ops (not-empty (mapcat (partial entity-datoms=>ops db-before db-after) same-entity-datoms-coll))]
-    (client-op/add-asset-ops repo ops)))
+  [repo _db-before db-after tx-data]
+  (let [related-datoms (filter
+                        (fn [datom]
+                          (and (asset-checksum? (:a datom)) (:added datom)))
+                        tx-data)]
+    (when-let [ops (not-empty (map #(datom=>op db-after %) related-datoms))]
+      (client-op/add-asset-ops repo ops))))
 
 (defmethod db-listener/listen-db-changes :gen-asset-change-events
   [_
-   {:keys [repo same-entity-datoms-coll]}
-   {:keys [_tx-data tx-meta db-before db-after]}]
+   {:keys [repo]}
+   {:keys [tx-data tx-meta db-before db-after]}]
   (when (and (client-op/rtc-db-graph? repo)
-             (:persist-op? tx-meta true))
-    (generate-asset-ops repo db-before db-after same-entity-datoms-coll)))
+             (:persist-op? tx-meta true)
+             (not (:rtc-tx? tx-meta)))
+    (generate-asset-ops repo db-before db-after tx-data)))