fix: can't upsert user in node adapter

deps/db-sync/src/logseq/db_sync/common.cljs

@@ -66,15 +66,20 @@
                      stmt)]
     (.run stmt)))
 
+(defn- with-session-db [^js db session-mode]
+  (let [with-session (.-withSession db)]
+    (if (fn? with-session)
+      (if (some? session-mode)
+        (.withSession db session-mode)
+        (.withSession db))
+      db)))
+
 (defn <d1-all
   [^js db sql-or-opts & more]
   (let [[opts sql-str args] (if (map? sql-or-opts)
                               [sql-or-opts (first more) (rest more)]
                               [nil sql-or-opts more])
-        session-mode (:session opts)
-        session (if (some? session-mode)
-                  (.withSession db session-mode)
-                  (.withSession db))]
+        session (with-session-db db (:session opts))]
     (p/let [^js stmt (.prepare session sql-str)
             ^js stmt (if (seq args)
                        (.apply (.-bind stmt) stmt (to-array args))

deps/db-sync/src/logseq/db_sync/worker/auth.cljs

@@ -2,37 +2,6 @@
   (:require [clojure.string :as string]
             [logseq.common.authorization :as authorization]))
 
-(defonce ^:private auth-cache (js/Map.))
-(defonce ^:private auth-cache-max-entries 512)
-(def ^:private auth-exp-skew-seconds 5)
-
-(defn- now-seconds []
-  (js/Math.floor (/ (.now js/Date) 1000)))
-
-(defn- evict-auth-cache! []
-  (when (> (.-size auth-cache) auth-cache-max-entries)
-    (let [keys-iter (.keys auth-cache)
-          first-key (.next keys-iter)]
-      (when-not (.-done first-key)
-        (.delete auth-cache (.-value first-key))))))
-
-(defn- cached-claims [token]
-  (let [entry (.get auth-cache token)]
-    (when entry
-      (let [exp (aget entry "exp")
-            now (now-seconds)]
-        (if (and (number? exp) (<= exp (+ now auth-exp-skew-seconds)))
-          (do
-            (.delete auth-cache token)
-            nil)
-          (aget entry "claims"))))))
-
-(defn- cache-claims! [token claims]
-  (let [exp (aget claims "exp")]
-    (when (and (string? token) (number? exp))
-      (.set auth-cache token #js {"claims" claims "exp" exp})
-      (evict-auth-cache!))))
-
 (defn- bearer-token [auth-header]
   (when (and (string? auth-header) (string/starts-with? auth-header "Bearer "))
     (subs auth-header 7)))
@@ -64,12 +33,5 @@
 (defn auth-claims [request env]
   (let [token (token-from-request request)]
     (if (string? token)
-      (if-let [claims (cached-claims token)]
-        (js/Promise.resolve claims)
-        (-> (authorization/verify-jwt token env)
-            (.then (fn [claims]
-                     (when claims
-                       (cache-claims! token claims))
-                     claims))
-            (.catch (fn [_] nil))))
+      (authorization/verify-jwt token env)
       (js/Promise.resolve nil))))

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

@@ -0,0 +1,91 @@
+(ns logseq.db-sync.common-test
+  (:require [cljs.test :refer [async deftest is]]
+            [logseq.db-sync.common :as common]
+            [promesa.core :as p]))
+
+(defn- make-stmt [calls result]
+  (let [stmt (js-obj)]
+    (aset stmt
+          "bind"
+          (fn [& args]
+            (swap! calls assoc :bind-args (vec args))
+            stmt))
+    (aset stmt
+          "all"
+          (fn []
+            (swap! calls update :all-count (fnil inc 0))
+            result))
+    stmt))
+
+(deftest d1-all-falls-back-when-with-session-missing-test
+  (async done
+         (let [calls (atom {})
+               result #js {:results #js [#js {"id" "u1"}]}
+               stmt (make-stmt calls result)
+               db #js {:prepare (fn [sql]
+                                  (swap! calls assoc :prepare-sql sql)
+                                  stmt)}]
+           (-> (p/let [query-result (common/<d1-all db
+                                                    "select id from users where id = ?"
+                                                    "u1")]
+                 (is (= result query-result))
+                 (is (= "select id from users where id = ?"
+                        (:prepare-sql @calls)))
+                 (is (= ["u1"] (:bind-args @calls)))
+                 (is (= 1 (:all-count @calls))))
+               (p/then (fn [] (done)))
+               (p/catch (fn [error]
+                          (is false (str error))
+                          (done)))))))
+
+(deftest d1-all-uses-with-session-mode-when-provided-test
+  (async done
+         (let [calls (atom {})
+               result #js {:results #js [#js {"id" "u1"}]}
+               stmt (make-stmt calls result)
+               session #js {:prepare (fn [sql]
+                                       (swap! calls assoc :prepare-sql sql)
+                                       stmt)}
+               db #js {:prepare (fn [_]
+                                  (throw (js/Error. "db.prepare should not be called")))
+                       :withSession (fn [& args]
+                                      (swap! calls assoc :with-session-args (vec args))
+                                      session)}]
+           (-> (p/let [query-result (common/<d1-all db
+                                                    {:session "first-primary"}
+                                                    "select id from users where id = ?"
+                                                    "u1")]
+                 (is (= result query-result))
+                 (is (= ["first-primary"] (:with-session-args @calls)))
+                 (is (= "select id from users where id = ?"
+                        (:prepare-sql @calls)))
+                 (is (= ["u1"] (:bind-args @calls)))
+                 (is (= 1 (:all-count @calls))))
+               (p/then (fn [] (done)))
+               (p/catch (fn [error]
+                          (is false (str error))
+                          (done)))))))
+
+(deftest d1-all-uses-default-with-session-when-no-mode-test
+  (async done
+         (let [calls (atom {})
+               result #js {:results #js []}
+               stmt (make-stmt calls result)
+               session #js {:prepare (fn [sql]
+                                       (swap! calls assoc :prepare-sql sql)
+                                       stmt)}
+               db #js {:prepare (fn [_]
+                                  (throw (js/Error. "db.prepare should not be called")))
+                       :withSession (fn [& args]
+                                      (swap! calls assoc :with-session-args (vec args))
+                                      session)}]
+           (-> (p/let [query-result (common/<d1-all db "select 1")]
+                 (is (= result query-result))
+                 (is (= [] (:with-session-args @calls)))
+                 (is (= "select 1" (:prepare-sql @calls)))
+                 (is (nil? (:bind-args @calls)))
+                 (is (= 1 (:all-count @calls))))
+               (p/then (fn [] (done)))
+               (p/catch (fn [error]
+                          (is false (str error))
+                          (done)))))))

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

@@ -1,5 +1,6 @@
 (ns logseq.db-sync.test-runner
   (:require [cljs.test :as ct]
+            [logseq.db-sync.common-test]
             [logseq.db-sync.node-adapter-test]
             [logseq.db-sync.node-config-test]
             [logseq.db-sync.platform-test]