refactor(db-sync): rename worker-sync to db-sync

.gitignore

@@ -70,9 +70,9 @@ deps/shui/.clj-kondo
 deps/publish/worker/.wrangler
 deps/publish/worker/dist
 deps/publish/worker/.env*
-deps/worker-sync/worker/.wrangler
-deps/worker-sync/worker/dist
-deps/worker-sync/worker/.env*
+deps/db-sync/worker/.wrangler
+deps/db-sync/worker/dist
+deps/db-sync/worker/.env*
 
 
 tx-log*

AGENTS.md

@@ -32,5 +32,5 @@
 
 ## Agent-Specific Notes
 - Review notes live in `@prompts/review.md`; check them when preparing changes.
-- Worker-sync feature guide for AI agents: `docs/agent-guide/worker-sync/worker-sync-guide.md`.
-- Worker-sync protocol reference: `docs/agent-guide/worker-sync/protocol.md`.
+- DB-sync feature guide for AI agents: `docs/agent-guide/db-sync/db-sync-guide.md`.
+- DB-sync protocol reference: `docs/agent-guide/db-sync/protocol.md`.

bb.edn

@@ -173,13 +173,13 @@
   {:doc "Run e2e rtc extra part2 tests. HTTP server should be available at localhost:3001"
    :task (clojure {:dir "clj-e2e"} "-X:dev-run-rtc-extra-part2-test")}
 
-  dev:worker-sync-test
-  {:doc "Run worker-sync unit tests"
-   :task (clojure {:dir "deps/worker-sync"} "-M:cljs" "compile" "worker-sync-test")}
+  dev:db-sync-test
+  {:doc "Run db-sync unit tests"
+   :task (clojure {:dir "deps/db-sync"} "-M:cljs" "compile" "db-sync-test")}
 
-  dev:worker-sync-start
-  {:doc "Start worker-sync local server + client watch processes in foreground"
-   :task logseq.tasks.dev.worker-sync/start}
+  dev:db-sync-start
+  {:doc "Start db-sync local server + client watch processes in foreground"
+   :task logseq.tasks.dev.db-sync/start}
 
   dev:gen-malli-kondo-config
   logseq.tasks.dev/gen-malli-kondo-config

deps/worker-sync/package.json → deps/db-sync/package.json

@@ -1,12 +1,12 @@
 {
-  "name": "@logseq/worker-sync",
+  "name": "@logseq/db-sync",
   "version": "1.0.0",
   "private": true,
   "scripts": {
     "dev": "cd ./worker && npx wrangler dev",
-    "watch": "clojure -M:cljs watch worker-sync",
-    "release": "clojure -M:cljs release worker-sync",
-    "test": "clojure -M:cljs compile worker-sync-test",
+    "watch": "clojure -M:cljs watch db-sync",
+    "release": "clojure -M:cljs release db-sync",
+    "test": "clojure -M:cljs compile db-sync-test",
     "clean": "rm -rf ./worker/dist/",
     "deploy": "yarn clean && yarn release && cd ./worker && wrangler deploy",
     "deploy-staging": "yarn clean && yarn release && cd ./worker && wrangler deploy --env staging"

deps/worker-sync/shadow-cljs.edn → deps/db-sync/shadow-cljs.edn

@@ -3,15 +3,15 @@
  :http {:port 9632}
  :nrepl {:port 8703}
  :builds
- {:worker-sync {:target :esm
+ {:db-sync {:target :esm
                 :output-dir "worker/dist/worker"
-                :modules {:main {:exports {default logseq.worker-sync.worker/worker
-                                           SyncDO logseq.worker-sync.worker/SyncDO
-                                           SyncIndexDO logseq.worker-sync.worker/SyncIndexDO}}}
+                :modules {:main {:exports {default logseq.db-sync.worker/worker
+                                           SyncDO logseq.db-sync.worker/SyncDO
+                                           SyncIndexDO logseq.db-sync.worker/SyncIndexDO}}}
                 :js-options {:js-provider :import}
                 :closure-defines {shadow.cljs.devtools.client.env/enabled false}
                 :devtools {:enabled false}}
-  :worker-sync-test {:target :node-test
+  :db-sync-test {:target :node-test
                      :output-to "worker/dist/worker-test.js"
                      :devtools {:enabled false}
-                     :main logseq.worker-sync.test-runner/main}}}
+                     :main logseq.db-sync.test-runner/main}}}

deps/worker-sync/src/logseq/worker_sync/common.cljs → deps/db-sync/src/logseq/db_sync/common.cljs

@@ -1,4 +1,4 @@
-(ns logseq.worker-sync.common
+(ns logseq.db-sync.common
   (:require [clojure.string :as string]
             [logseq.db.sqlite.util :as sqlite-util]
             [promesa.core :as p]))

deps/worker-sync/src/logseq/worker_sync/cycle.cljs → deps/db-sync/src/logseq/db_sync/cycle.cljs

@@ -1,4 +1,4 @@
-(ns logseq.worker-sync.cycle
+(ns logseq.db-sync.cycle
   (:require [datascript.core :as d]
             [datascript.impl.entity :as de :refer [Entity]]))
 

deps/worker-sync/src/logseq/worker_sync/protocol.cljs → deps/db-sync/src/logseq/db_sync/protocol.cljs

@@ -1,5 +1,5 @@
-(ns logseq.worker-sync.protocol
-  (:require [logseq.worker-sync.common :as common]))
+(ns logseq.db-sync.protocol
+  (:require [logseq.db-sync.common :as common]))
 
 (defn parse-message [raw]
   (try

deps/worker-sync/src/logseq/worker_sync/storage.cljs → deps/db-sync/src/logseq/db_sync/storage.cljs

@@ -1,10 +1,10 @@
-(ns logseq.worker-sync.storage
+(ns logseq.db-sync.storage
   (:require [cljs-bean.core :as bean]
             [clojure.string :as string]
             [datascript.storage :refer [IStorage]]
             [logseq.db.common.sqlite :as common-sqlite]
             [logseq.db.frontend.schema :as db-schema]
-            [logseq.worker-sync.common :as common]))
+            [logseq.db-sync.common :as common]))
 
 (defn init-schema! [sql]
   (common/sql-exec sql "create table if not exists kvs (addr INTEGER primary key, content TEXT, addresses JSON)")

deps/worker-sync/src/logseq/worker_sync/worker.cljs → deps/db-sync/src/logseq/db_sync/worker.cljs

@@ -1,4 +1,4 @@
-(ns logseq.worker-sync.worker
+(ns logseq.db-sync.worker
   (:require ["cloudflare:workers" :refer [DurableObject]]
             [clojure.string :as string]
             [datascript.core :as d]
@@ -7,11 +7,11 @@
             [logseq.common.authorization :as authorization]
             [logseq.db :as ldb]
             [logseq.db.common.normalize :as db-normalize]
-            [logseq.worker-sync.common :as common :refer [cors-headers]]
-            [logseq.worker-sync.cycle :as cycle]
-            [logseq.worker-sync.protocol :as protocol]
-            [logseq.worker-sync.storage :as storage]
-            [logseq.worker-sync.worker-core :as worker-core]
+            [logseq.db-sync.common :as common :refer [cors-headers]]
+            [logseq.db-sync.cycle :as cycle]
+            [logseq.db-sync.protocol :as protocol]
+            [logseq.db-sync.storage :as storage]
+            [logseq.db-sync.worker-core :as worker-core]
             [promesa.core :as p]
             [shadow.cljs.modern :refer (defclass)]))
 
@@ -350,7 +350,7 @@
             (if (instance? js/Promise resp)
               (.catch resp
                       (fn [e]
-                        (log/error :worker-sync/http-error {:error e})
+                        (log/error :db-sync/http-error {:error e})
                         (common/json-response {:error "server error"} 500)))
               resp))]
     (try
@@ -421,7 +421,7 @@
             :else
             (common/not-found))))
       (catch :default e
-        (log/error :worker-sync/http-error {:error e})
+        (log/error :db-sync/http-error {:error e})
         (common/json-response {:error "server error"} 500)))))
 
 (defclass SyncDO
@@ -443,13 +443,13 @@
                     (try
                       (handle-ws-message! this ws message)
                       (catch :default e
-                        (log/error :worker-sync/ws-error e)
+                        (log/error :db-sync/ws-error e)
                         (js/console.error e)
                         (send! ws {:type "error" :message "server error"}))))
   (webSocketClose [_this _ws _code _reason]
-                  (log/info :worker-sync/ws-closed true))
+                  (log/info :db-sync/ws-closed true))
   (webSocketError [_this _ws error]
-                  (log/error :worker-sync/ws-error {:error error})))
+                  (log/error :db-sync/ws-error {:error error})))
 
 (defn- index-init! [sql]
   (common/sql-exec sql
@@ -595,7 +595,7 @@
               :else
               (common/not-found)))))
       (catch :default error
-        (log/error :worker-sync/index-error error)
+        (log/error :db-sync/index-error error)
         (common/json-response {:error "server error"} 500)))))
 
 (defclass SyncIndexDO

deps/worker-sync/src/logseq/worker_sync/worker_core.cljs → deps/db-sync/src/logseq/db_sync/worker_core.cljs

@@ -1,11 +1,11 @@
-(ns logseq.worker-sync.worker-core
+(ns logseq.db-sync.worker-core
   (:require [datascript.core :as d]
             [logseq.common.config :as common-config]
             [logseq.common.util :as common-util]
             [logseq.common.util.date-time :as date-time]
             [logseq.common.uuid :as common-uuid]
             [logseq.db.common.order :as db-order]
-            [logseq.worker-sync.common :as common]))
+            [logseq.db-sync.common :as common]))
 
 (defn- journal-page-info []
   (let [now (common/now-ms)

deps/worker-sync/test/logseq/worker_sync/cycle_test.cljs → deps/db-sync/test/logseq/db_sync/cycle_test.cljs

@@ -1,8 +1,8 @@
-(ns logseq.worker-sync.cycle-test
+(ns logseq.db-sync.cycle-test
   (:require [cljs.test :refer [deftest is testing]]
             [datascript.core :as d]
             [logseq.db.frontend.schema :as db-schema]
-            [logseq.worker-sync.cycle :as cycle]))
+            [logseq.db-sync.cycle :as cycle]))
 
 (defn- new-conn []
   (d/create-conn db-schema/schema))

deps/worker-sync/test/logseq/worker_sync/storage_test.cljs → deps/db-sync/test/logseq/db_sync/storage_test.cljs

@@ -1,7 +1,7 @@
-(ns logseq.worker-sync.storage-test
+(ns logseq.db-sync.storage-test
   (:require [cljs.test :refer [deftest is]]
-            [logseq.worker-sync.storage :as storage]
-            [logseq.worker-sync.test-sql :as test-sql]))
+            [logseq.db-sync.storage :as storage]
+            [logseq.db-sync.test-sql :as test-sql]))
 
 (deftest t-counter-test
   (let [sql (test-sql/make-sql)]

deps/worker-sync/test/logseq/worker_sync/test_runner.cljs → deps/db-sync/test/logseq/db_sync/test_runner.cljs

@@ -1,4 +1,4 @@
-(ns logseq.worker-sync.test-runner
+(ns logseq.db-sync.test-runner
   (:require [cljs.test :as ct]
             [shadow.test :as st]
             [shadow.test.env :as env]))

deps/worker-sync/test/logseq/worker_sync/test_sql.cljs → deps/db-sync/test/logseq/db_sync/test_sql.cljs

@@ -1,4 +1,4 @@
-(ns logseq.worker-sync.test-sql
+(ns logseq.db-sync.test-sql
   (:require [clojure.string :as string]))
 
 (defn- js-row [m]

deps/worker-sync/test/logseq/worker_sync/worker_test.cljs → deps/db-sync/test/logseq/db_sync/worker_test.cljs

@@ -1,12 +1,12 @@
-(ns logseq.worker-sync.worker-test
+(ns logseq.db-sync.worker-test
   (:require [cljs.test :refer [deftest is testing]]
             [datascript.core :as d]
             [logseq.common.util.date-time :as date-time]
             [logseq.common.uuid :as common-uuid]
             [logseq.db.common.order :as db-order]
             [logseq.db.frontend.schema :as db-schema]
-            [logseq.worker-sync.common :as common]
-            [logseq.worker-sync.worker-core :as worker-core]))
+            [logseq.db-sync.common :as common]
+            [logseq.db-sync.worker-core :as worker-core]))
 
 (defn- new-conn []
   (d/create-conn db-schema/schema))

deps/worker-sync/worker/README.md → deps/db-sync/worker/README.md

@@ -47,9 +47,9 @@ Server -> Client:
 ### Notes
 
 - The sync protocol is intentionally minimal for testing.
-- For local testing, run `wrangler dev` and use `deps/worker-sync/worker/scripts/dev_test.sh`.
-- For WebSocket testing, run `node deps/worker-sync/worker/scripts/ws_test.js`.
+- For local testing, run `wrangler dev` and use `deps/db-sync/worker/scripts/dev_test.sh`.
+- For WebSocket testing, run `node deps/db-sync/worker/scripts/ws_test.js`.
 - If you switch schema versions, clear local DO state.
-- Build the worker bundle with `clojure -M:cljs release worker-sync`.
-- For dev, run `clojure -M:cljs watch worker-sync` in one terminal and
+- Build the worker bundle with `clojure -M:cljs release db-sync`.
+- For dev, run `clojure -M:cljs watch db-sync` in one terminal and
   `wrangler dev` in another.

docs/agent-guide/worker-sync/worker-sync-guide.md → docs/agent-guide/db-sync/db-sync-guide.md

@@ -1,25 +1,25 @@
-# Worker-Sync Feature Agent Guide
+# DB-Sync Feature Agent Guide
 
 ## Purpose
-This guide helps AI agents implement and review worker-sync features consistently across the client and the Cloudflare Worker. Keep changes scoped, follow the existing flow, and document any protocol or storage changes. Keep this document accurate (file names, paths, commands, and parameters).
+This guide helps AI agents implement and review db-sync features consistently across the client and the Cloudflare Worker. Keep changes scoped, follow the existing flow, and document any protocol or storage changes. Keep this document accurate (file names, paths, commands, and parameters).
 
 ## Key Code Locations
 - Client config: `src/main/frontend/config.cljs`
-- Client runtime: `src/main/frontend/worker/worker_sync.cljs`
+- Client runtime: `src/main/frontend/worker/db_sync.cljs`
 - Worker thread API: `src/main/frontend/worker/db_worker.cljs`
-- Handler entry points: `src/main/frontend/handler/db_based/worker_sync.cljs`
-- Server worker code: `deps/worker-sync/src/logseq/worker_sync/`
-- Worker build/test notes: `deps/worker-sync/worker/README.md`
+- Handler entry points: `src/main/frontend/handler/db_based/db_sync.cljs`
+- Server worker code: `deps/db-sync/src/logseq/db_sync/`
+- Worker build/test notes: `deps/db-sync/worker/README.md`
 
 ## Implementation Workflow
 1) **Define behavior**: state the new capability, expected inputs/outputs, and compatibility requirements.
 2) **Update protocol first** (if needed): change `protocol.cljs` and adjust server/client serialization in tandem.
 3) **Server changes**: update `worker.cljs`, `worker_core.cljs`, `storage.cljs`, or `cycle.cljs`.
-4) **Client changes**: update `worker_sync.cljs` and thread APIs in `db_worker.cljs`.
-5) **Handler glue**: add or adjust the entry points in `handler/db_based/worker_sync.cljs`.
+4) **Client changes**: update `db_sync.cljs` and thread APIs in `db_worker.cljs`.
+5) **Handler glue**: add or adjust the entry points in `handler/db_based/db_sync.cljs`.
 
 ## Data, Keywords, and Schema
-- Use existing `:worker-sync/*` keywords; add new keywords via `logseq.common.defkeywords/defkeyword`.
+- Use existing `:db-sync/*` keywords; add new keywords via `logseq.common.defkeywords/defkeyword`.
 - When adding persisted fields, ensure any migration or index logic is updated on both client and worker.
 
 ## Client-Server Message Protocol (WebSocket)
@@ -42,14 +42,14 @@ This guide helps AI agents implement and review worker-sync features consistentl
   - `{"type":"error","message":"..."}`: invalid/unknown message.
 
 ## Testing & Verification
-- Local dev(client+server): `bb dev:worker-sync-start` runs the worker-sync watcher, `wrangler dev`, and `yarn watch` with `ENABLE_WORKER_SYNC_LOCAL=true`
+- Local dev(client+server): `bb dev:db-sync-start` runs the db-sync watcher, `wrangler dev`, and `yarn watch` with `ENABLE_DB_SYNC_LOCAL=true`
 - Unit tests: `bb dev:lint-and-test`
-- Worker-sync tests: `bb dev:worker-sync-test`
-- Single test example: `bb dev:test -v logseq.worker-sync.storage-test/foo`
-- Worker local build: `clojure -M:cljs release worker-sync`
+- DB-sync tests: `bb dev:db-sync-test`
+- Single test example: `bb dev:test -v logseq.db-sync.storage-test/foo`
+- Worker local build: `clojure -M:cljs release db-sync`
 
 ## Review Checklist
 - Protocol versioning and error handling are consistent across client/server.
 - No breaking changes without fallback or migration.
 - New data fields are indexed or stored intentionally.
-- Logs and errors use `:worker-sync/*` context keys.
+- Logs and errors use `:db-sync/*` context keys.

docs/agent-guide/worker-sync/protocol.md → docs/agent-guide/db-sync/protocol.md

@@ -1,4 +1,4 @@
-# Worker-Sync Client-Server Protocol
+# DB-Sync Client-Server Protocol
 
 ## Transport
 - WebSocket `ws(s)` to `/sync/:graph-id`.

scripts/src/logseq/tasks/dev/worker_sync.clj → scripts/src/logseq/tasks/dev/db_sync.clj

@@ -1,21 +1,21 @@
-(ns logseq.tasks.dev.worker-sync
-  "Tasks for worker-sync dev processes"
+(ns logseq.tasks.dev.db-sync
+  "Tasks for db-sync dev processes"
   (:require [babashka.process :refer [process]]))
 
 (def processes
-  [{:name "worker-sync-watch"
-    :dir "deps/worker-sync"
-    :cmd "clojure -M:cljs watch worker-sync"}
+  [{:name "db-sync-watch"
+    :dir "deps/db-sync"
+    :cmd "clojure -M:cljs watch db-sync"}
    {:name "wrangler-dev"
-    :dir "deps/worker-sync/worker"
+    :dir "deps/db-sync/worker"
     :cmd "wrangler dev"}
    {:name "yarn-watch"
     :dir "."
-    :cmd "ENABLE_WORKER_SYNC_LOCAL=true yarn watch"}])
+    :cmd "ENABLE_DB_SYNC_LOCAL=true yarn watch"}])
 
 (defn start
   []
-  (println "Starting worker-sync processes in foreground.")
+  (println "Starting db-sync processes in foreground.")
   (println "Use Ctrl-C to stop.")
   (let [procs (mapv (fn [{:keys [name dir cmd]}]
                       (println "Running:" name "-" cmd)

shadow-cljs.edn

@@ -45,7 +45,7 @@
                           frontend.config/ENABLE-FILE-SYNC-PRODUCTION #shadow/env ["ENABLE_FILE_SYNC_PRODUCTION" :as :bool :default true]
                           frontend.config/ENABLE-RTC-SYNC-PRODUCTION #shadow/env ["ENABLE_RTC_SYNC_PRODUCTION" :as :bool :default true]
 
-                          frontend.config/ENABLE-WORKER-SYNC-LOCAL #shadow/env ["ENABLE_WORKER_SYNC_LOCAL" :as :bool :default false]
+                          frontend.config/ENABLE-DB-SYNC-LOCAL #shadow/env ["ENABLE_DB_SYNC_LOCAL" :as :bool :default false]
                           frontend.config/REVISION #shadow/env ["LOGSEQ_REVISION" :default "dev"]} ;; set by git-revision-hook
 
         :devtools {:before-load frontend.core/stop          ;; before live-reloading any code call this function
@@ -149,7 +149,7 @@
             frontend.config/ENABLE-FILE-SYNC-PRODUCTION #shadow/env ["ENABLE_FILE_SYNC_PRODUCTION" :as :bool :default true]
             frontend.config/ENABLE-RTC-SYNC-PRODUCTION #shadow/env ["ENABLE_RTC_SYNC_PRODUCTION" :as :bool :default true]
 
-            frontend.config/ENABLE-WORKER-SYNC-LOCAL #shadow/env ["ENABLE_WORKER_SYNC_LOCAL" :as :bool :default false]
+            frontend.config/ENABLE-DB-SYNC-LOCAL #shadow/env ["ENABLE_DB_SYNC_LOCAL" :as :bool :default false]
             frontend.config/REVISION #shadow/env ["LOGSEQ_REVISION" :default "dev"]}
 
            :devtools {:before-load mobile.core/stop!          ;; before live-reloading any code call this function

src/main/frontend/config.cljs

@@ -55,20 +55,20 @@
   (def RTC-WS-URL "wss://ws.logseq.com/rtc-sync?token=%s")
   (def RTC-WS-URL "wss://ws-dev.logseq.com/rtc-sync?token=%s"))
 
-;; (goog-define ENABLE-WORKER-SYNC false)
-(goog-define ENABLE-WORKER-SYNC true)
-(defonce worker-sync-enabled? ENABLE-WORKER-SYNC)
+;; (goog-define ENABLE-DB-SYNC false)
+(goog-define ENABLE-DB-SYNC true)
+(defonce db-sync-enabled? ENABLE-DB-SYNC)
 
-(goog-define ENABLE-WORKER-SYNC-LOCAL false)
-(defonce worker-sync-local? ENABLE-WORKER-SYNC-LOCAL)
+(goog-define ENABLE-DB-SYNC-LOCAL false)
+(defonce db-sync-local? ENABLE-DB-SYNC-LOCAL)
 
-(defonce worker-sync-ws-url
-  (if worker-sync-local?
+(defonce db-sync-ws-url
+  (if db-sync-local?
     "ws://127.0.0.1:8787/sync/%s"
     "wss://logseq-sync.logseq.workers.dev/sync/%s"))
 
-(defonce worker-sync-http-base
-  (if worker-sync-local?
+(defonce db-sync-http-base
+  (if db-sync-local?
     "http://127.0.0.1:8787"
     "https://logseq-sync.logseq.workers.dev"))
 

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

@@ -1,5 +1,5 @@
-(ns frontend.handler.db-based.worker-sync
-  "Worker-sync handler based on Cloudflare Durable Objects."
+(ns frontend.handler.db-based.db-sync
+  "DB-sync handler based on Cloudflare Durable Objects."
   (:require [clojure.string :as string]
             [frontend.config :as config]
             [frontend.db :as db]
@@ -26,8 +26,8 @@
       base)))
 
 (defn- http-base []
-  (or config/worker-sync-http-base
-      (ws->http-base config/worker-sync-ws-url)))
+  (or config/db-sync-http-base
+      (ws->http-base config/db-sync-ws-url)))
 
 (def ^:private snapshot-rows-limit 2000)
 
@@ -47,20 +47,20 @@
           data (when (seq text) (js/JSON.parse text))]
     (if (.-ok resp)
       data
-      (throw (ex-info "worker-sync request failed"
+      (throw (ex-info "db-sync request failed"
                       {:status (.-status resp)
                        :url url
                        :body data})))))
 
 (defn <rtc-start!
   [repo & {:keys [_stop-before-start?] :as _opts}]
-  (log/info :worker-sync/start {:repo repo})
-  (state/<invoke-db-worker :thread-api/worker-sync-start repo))
+  (log/info :db-sync/start {:repo repo})
+  (state/<invoke-db-worker :thread-api/db-sync-start repo))
 
 (defn <rtc-stop!
   []
-  (log/info :worker-sync/stop true)
-  (state/<invoke-db-worker :thread-api/worker-sync-stop))
+  (log/info :db-sync/stop true)
+  (state/<invoke-db-worker :thread-api/db-sync-stop))
 
 (defn <rtc-get-users-info
   []
@@ -84,11 +84,11 @@
            (ldb/transact! repo [(sqlite-util/kv :logseq.kv/db-type "db")
                                 (sqlite-util/kv :logseq.kv/graph-uuid (uuid graph-id))])
            graph-id)
-          (p/rejected (ex-info "worker-sync missing graph id in create response"
-                               {:type :worker-sync/invalid-graph
+          (p/rejected (ex-info "db-sync missing graph id in create response"
+                               {:type :db-sync/invalid-graph
                                 :response result}))))
-      (p/rejected (ex-info "worker-sync missing graph info"
-                           {:type :worker-sync/invalid-graph
+      (p/rejected (ex-info "db-sync missing graph info"
+                           {:type :db-sync/invalid-graph
                             :base base})))))
 
 (defn <rtc-delete-graph!
@@ -97,8 +97,8 @@
     (if (and graph-uuid base)
       (p/let [_ (js/Promise. user-handler/task--ensure-id&access-token)]
         (fetch-json (str base "/graphs/" graph-uuid) {:method "DELETE"}))
-      (p/rejected (ex-info "worker-sync missing graph id"
-                           {:type :worker-sync/invalid-graph
+      (p/rejected (ex-info "db-sync missing graph id"
+                           {:type :db-sync/invalid-graph
                             :graph-uuid graph-uuid
                             :base base})))))
 
@@ -125,13 +125,13 @@
                       done? (true? (aget resp "done"))
                       last-addr (or (aget resp "last_addr") after)]
                 (p/do!
-                 (state/<invoke-db-worker :thread-api/worker-sync-import-kvs-rows
+                 (state/<invoke-db-worker :thread-api/db-sync-import-kvs-rows
                                           graph rows first-batch?)
                  (if done?
-                   (state/<invoke-db-worker :thread-api/worker-sync-finalize-kvs-import graph remote-tx)
+                   (state/<invoke-db-worker :thread-api/db-sync-finalize-kvs-import graph remote-tx)
                    (p/recur last-addr false))))))
-          (p/rejected (ex-info "worker-sync missing graph info"
-                               {:type :worker-sync/invalid-graph
+          (p/rejected (ex-info "db-sync missing graph info"
+                               {:type :db-sync/invalid-graph
                                 :graph-uuid graph-uuid
                                 :base base})))
         (p/catch (fn [error]

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

@@ -1,34 +1,34 @@
 (ns frontend.handler.db-based.sync
-  "Dispatch RTC calls between legacy RTC and worker-sync implementations."
+  "Dispatch RTC calls between legacy RTC and db-sync implementations."
   (:require [frontend.config :as config]
             [frontend.db :as db]
             [frontend.handler.db-based.rtc :as rtc-handler]
-            [frontend.handler.db-based.worker-sync :as worker-sync-handler]
+            [frontend.handler.db-based.db-sync :as db-sync-handler]
             [frontend.state :as state]
             [logseq.db :as ldb]
             [promesa.core :as p]))
 
-(defn- worker-sync-enabled? []
-  config/worker-sync-enabled?)
+(defn- db-sync-enabled? []
+  config/db-sync-enabled?)
 
 (defn <rtc-create-graph! [repo]
-  (if (worker-sync-enabled?)
-    (worker-sync-handler/<rtc-create-graph! repo)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<rtc-create-graph! repo)
     (rtc-handler/<rtc-create-graph! repo)))
 
 (defn <rtc-delete-graph! [graph-uuid schema-version]
-  (if (worker-sync-enabled?)
-    (worker-sync-handler/<rtc-delete-graph! graph-uuid schema-version)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<rtc-delete-graph! graph-uuid schema-version)
     (rtc-handler/<rtc-delete-graph! graph-uuid schema-version)))
 
 (defn <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)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<rtc-download-graph! graph-name graph-uuid graph-schema-version)
     (rtc-handler/<rtc-download-graph! graph-name graph-uuid graph-schema-version timeout-ms)))
 
 (defn <rtc-stop! []
-  (if (worker-sync-enabled?)
-    (worker-sync-handler/<rtc-stop!)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<rtc-stop!)
     (rtc-handler/<rtc-stop!)))
 
 (defn <rtc-branch-graph! [repo]
@@ -38,30 +38,30 @@
   (rtc-handler/notification-download-higher-schema-graph! graph-name graph-uuid schema-version))
 
 (defn <rtc-get-users-info []
-  (if (worker-sync-enabled?)
-    (worker-sync-handler/<rtc-get-users-info)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<rtc-get-users-info)
     (rtc-handler/<rtc-get-users-info)))
 
 (defn <rtc-start!
   [repo & {:keys [stop-before-start?] :or {stop-before-start? true}}]
-  (if (worker-sync-enabled?)
-    (worker-sync-handler/<rtc-start! repo :stop-before-start? stop-before-start?)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<rtc-start! repo :stop-before-start? stop-before-start?)
     (rtc-handler/<rtc-start! repo :stop-before-start? stop-before-start?)))
 
 (defn <rtc-upload-graph! [repo token remote-graph-name]
-  (if (worker-sync-enabled?)
-    (p/let [graph-id (worker-sync-handler/<rtc-create-graph! repo)]
+  (if (db-sync-enabled?)
+    (p/let [graph-id (db-sync-handler/<rtc-create-graph! repo)]
       (when (nil? graph-id)
         (throw (ex-info "graph id doesn't exist when uploading to server" {:repo repo})))
       (p/do!
-       (state/<invoke-db-worker :thread-api/worker-sync-upload-graph repo)
+       (state/<invoke-db-worker :thread-api/db-sync-upload-graph repo)
        (<rtc-start! repo)))
     (state/<invoke-db-worker :thread-api/rtc-async-upload-graph
                              repo token remote-graph-name)))
 
 (defn <get-remote-graphs []
-  (if (worker-sync-enabled?)
-    (worker-sync-handler/<get-remote-graphs)
+  (if (db-sync-enabled?)
+    (db-sync-handler/<get-remote-graphs)
     (rtc-handler/<get-remote-graphs)))
 
 (defn <rtc-invite-email [graph-uuid email]

src/main/frontend/persist_db/browser.cljs

@@ -145,10 +145,10 @@
        (worker-handler/handle-message! worker wrapped-worker)
        (reset! state/*db-worker wrapped-worker)
        (-> (p/let [_ (state/<invoke-db-worker :thread-api/init config/RTC-WS-URL)
-                   _ (state/<invoke-db-worker :thread-api/set-worker-sync-config
-                                              {:enabled? config/worker-sync-enabled?
-                                               :ws-url config/worker-sync-ws-url
-                                               :http-base config/worker-sync-http-base})
+                   _ (state/<invoke-db-worker :thread-api/set-db-sync-config
+                                              {:enabled? config/db-sync-enabled?
+                                               :ws-url config/db-sync-ws-url
+                                               :http-base config/db-sync-http-base})
                    _ (sync-app-state!)
                    _ (log/info "init worker spent" (str (- (util/time-ms) t1) "ms"))
                    _ (sync-ui-state!)

src/main/frontend/worker/db_listener.cljs

@@ -8,7 +8,7 @@
             [frontend.worker.search :as search]
             [frontend.worker.shared-service :as shared-service]
             [frontend.worker.state :as worker-state]
-            [frontend.worker.worker-sync :as worker-sync]
+            [frontend.worker.db-sync :as db-sync]
             [logseq.common.util :as common-util]
             [logseq.db :as ldb]
             [logseq.outliner.batch-tx :as batch-tx]
@@ -51,9 +51,9 @@
     (prn :tx-data tx-data)
     (prn :tx-meta tx-meta)))
 
-(defmethod listen-db-changes :worker-sync
+(defmethod listen-db-changes :db-sync
   [_ {:keys [repo]} tx-report]
-  (worker-sync/handle-local-tx! repo tx-report))
+  (db-sync/handle-local-tx! repo tx-report))
 
 (defn- remove-old-embeddings-and-reset-new-updates!
   [conn tx-data tx-meta]

src/main/frontend/worker/worker_sync.cljs → src/main/frontend/worker/db_sync.cljs

@@ -1,5 +1,5 @@
-(ns frontend.worker.worker-sync
-  "Simple worker-sync client based on promesa + WebSocket."
+(ns frontend.worker.db-sync
+  "Simple db-sync client based on promesa + WebSocket."
   (:require [clojure.string :as string]
             [datascript.core :as d]
             [frontend.worker.rtc.client-op :as client-op]
@@ -13,15 +13,15 @@
 
 (defn- enabled?
   []
-  (true? (:enabled? @worker-state/*worker-sync-config)))
+  (true? (:enabled? @worker-state/*db-sync-config)))
 
 (defn- ws-base-url
   []
-  (:ws-url @worker-state/*worker-sync-config))
+  (:ws-url @worker-state/*db-sync-config))
 
 (defn- http-base-url
   []
-  (or (:http-base @worker-state/*worker-sync-config)
+  (or (:http-base @worker-state/*db-sync-config)
       (when-let [ws-url (ws-base-url)]
         (let [base (cond
                      (string/starts-with? ws-url "wss://")
@@ -125,7 +125,7 @@
           data (when (seq text) (js/JSON.parse text))]
     (if (.-ok resp)
       (js->clj data :keywordize-keys true)
-      (throw (ex-info "worker-sync request failed"
+      (throw (ex-info "db-sync request failed"
                       {:status (.-status resp)
                        :url url
                        :body data})))))
@@ -155,7 +155,7 @@
         (when (seq asset-uuids)
           (enqueue-asset-downloads! repo client asset-uuids)))
       (catch :default e
-        (log/error :worker-sync/apply-remote-tx-failed {:error e})))))
+        (log/error :db-sync/apply-remote-tx-failed {:error e})))))
 
 (defn- reconcile-cycle! [repo attr server_values]
   (when-let [conn (worker-state/get-datascript-conn repo)]
@@ -220,13 +220,13 @@
         nil))))
 
 (defn- ensure-client-state! [repo]
-  (or (get @worker-state/*worker-sync-clients repo)
+  (or (get @worker-state/*db-sync-clients repo)
       (let [client {:repo repo
                     :send-queue (atom (p/resolved nil))
                     :asset-queue (atom (p/resolved nil))
                     :inflight (atom [])
                     :reconnect (atom {:attempt 0 :timer nil})}]
-        (swap! worker-state/*worker-sync-clients assoc repo client)
+        (swap! worker-state/*db-sync-clients assoc repo client)
         client)))
 
 (defn- asset-url [base graph-id asset-uuid asset-type]
@@ -256,10 +256,10 @@
               opts (with-auth-headers {:method "DELETE"})
               resp (js/fetch url (clj->js opts))]
         (when-not (.-ok resp)
-          (log/error :worker-sync/asset-delete-failed {:repo repo
+          (log/error :db-sync/asset-delete-failed {:repo repo
                                                        :asset-uuid asset-uuid
                                                        :status (.-status resp)})))
-      (log/info :worker-sync/asset-delete-skipped {:repo repo
+      (log/info :db-sync/asset-delete-skipped {:repo repo
                                                    :asset-uuid asset-uuid
                                                    :reason :missing-base-or-type}))))
 
@@ -312,7 +312,7 @@
 
             (> size max-asset-size)
             (do
-              (log/info :worker-sync/asset-too-large {:repo repo
+              (log/info :db-sync/asset-too-large {:repo repo
                                                       :asset-uuid asset-uuid
                                                       :size size})
               (client-op/remove-asset-op repo asset-uuid)
@@ -336,7 +336,7 @@
                              :rtc.exception/upload-asset-failed
                              nil
 
-                             (log/error :worker-sync/asset-upload-failed
+                             (log/error :db-sync/asset-upload-failed
                                         {:repo repo
                                          :asset-uuid asset-uuid
                                          :error e})))))))
@@ -353,7 +353,7 @@
                (delete-remote-asset! repo graph-id asset-uuid asset-type))
              (client-op/remove-asset-op repo asset-uuid)))
           (p/catch (fn [e]
-                     (log/error :worker-sync/asset-delete-failed
+                     (log/error :db-sync/asset-delete-failed
                                 {:repo repo
                                  :asset-uuid asset-uuid
                                  :error e}))))
@@ -435,7 +435,7 @@
                                               (download-remote-asset! repo graph-id asset-uuid asset-type)
                                               (p/recur (rest entries))))))))
                                    (p/catch (fn [e]
-                                              (log/error :worker-sync/asset-initial-download-failed
+                                              (log/error :db-sync/asset-initial-download-failed
                                                          {:repo repo :error e}))))
                                (p/resolved nil)))
                            (p/resolved nil)))))
@@ -447,23 +447,23 @@
   (when-let [conn (client-ops-conn repo)]
     (let [tx-id (random-uuid)
           now (.now js/Date)]
-      (ldb/transact! conn [{:worker-sync/tx-id tx-id
-                            :worker-sync/tx tx-str
-                            :worker-sync/created-at now}])
+      (ldb/transact! conn [{:db-sync/tx-id tx-id
+                            :db-sync/tx tx-str
+                            :db-sync/created-at now}])
       tx-id)))
 
 (defn- pending-txs
   [repo limit]
   (when-let [conn (client-ops-conn repo)]
     (let [db @conn
-          datoms (d/datoms db :avet :worker-sync/created-at)]
+          datoms (d/datoms db :avet :db-sync/created-at)]
       (->> datoms
            (map (fn [datom]
                   (d/entity db (:e datom))))
            (keep (fn [ent]
-                   (when-let [tx-id (:worker-sync/tx-id ent)]
+                   (when-let [tx-id (:db-sync/tx-id ent)]
                      {:tx-id tx-id
-                      :tx (:worker-sync/tx ent)})))
+                      :tx (:db-sync/tx ent)})))
            (take limit)
            (vec)))))
 
@@ -473,7 +473,7 @@
     (when-let [conn (client-ops-conn repo)]
       (ldb/transact! conn
                      (mapv (fn [tx-id]
-                             [:db.fn/retractEntity [:worker-sync/tx-id tx-id]])
+                             [:db.fn/retractEntity [:db-sync/tx-id tx-id]])
                            tx-ids)))))
 
 (defn- flush-pending!
@@ -504,13 +504,13 @@
                             (fn []
                               (swap! reconnect assoc :timer nil)
                               (when (enabled?)
-                                (when-let [current (get @worker-state/*worker-sync-clients repo)]
+                                (when-let [current (get @worker-state/*db-sync-clients repo)]
                                   (when (= (:graph-id current) (:graph-id client))
                                     (let [updated (connect! repo current url)]
-                                      (swap! worker-state/*worker-sync-clients assoc repo updated))))))
+                                      (swap! worker-state/*db-sync-clients assoc repo updated))))))
                             delay)]
             (swap! reconnect assoc :timer timeout-id :attempt (inc attempt))
-            (log/info :worker-sync/ws-reconnect-scheduled
+            (log/info :db-sync/ws-reconnect-scheduled
                       {:repo repo :delay delay :attempt attempt :reason reason})))))))
 
 (defn- attach-ws-handlers! [repo client ws url]
@@ -519,10 +519,10 @@
           (handle-message! repo client (.-data event))))
   (set! (.-onerror ws)
         (fn [event]
-          (log/error :worker-sync/ws-error {:repo repo :error event})))
+          (log/error :db-sync/ws-error {:repo repo :error event})))
   (set! (.-onclose ws)
         (fn [_]
-          (log/info :worker-sync/ws-closed {:repo repo})
+          (log/info :db-sync/ws-closed {:repo repo})
           (schedule-reconnect! repo client url :close))))
 
 (defn- start-pull-loop! [client _ws]
@@ -551,14 +551,14 @@
 
 (defn stop!
   ([]
-   (doseq [[repo client] @worker-state/*worker-sync-clients]
+   (doseq [[repo client] @worker-state/*db-sync-clients]
      (stop-client! client)
-     (swap! worker-state/*worker-sync-clients dissoc repo))
+     (swap! worker-state/*db-sync-clients dissoc repo))
    (p/resolved nil))
   ([repo]
-   (when-let [client (get @worker-state/*worker-sync-clients repo)]
+   (when-let [client (get @worker-state/*db-sync-clients repo)]
      (stop-client! client)
-     (swap! worker-state/*worker-sync-clients dissoc repo))
+     (swap! worker-state/*db-sync-clients dissoc repo))
    (p/resolved nil)))
 
 (defn start!
@@ -575,10 +575,10 @@
                _ (ensure-client-graph-uuid! repo graph-id)
                connected (assoc client :graph-id graph-id)
                connected (connect! repo connected url)]
-           (swap! worker-state/*worker-sync-clients assoc repo connected)
+           (swap! worker-state/*db-sync-clients assoc repo connected)
            (p/resolved nil))
          (do
-           (log/info :worker-sync/start-skipped {:repo repo :graph-id graph-id :base base})
+           (log/info :db-sync/start-skipped {:repo repo :graph-id graph-id :base base})
            (p/resolved nil)))))))
 
 (defn enqueue-local-tx!
@@ -591,13 +591,13 @@
       (let [normalized (normalize-tx-data db-after db-before tx-data')
             tx-str (sqlite-util/write-transit-str normalized)]
         (persist-local-tx! repo tx-str)
-        (when-let [client (get @worker-state/*worker-sync-clients repo)]
+        (when-let [client (get @worker-state/*db-sync-clients repo)]
           (let [send-queue (:send-queue client)]
             (swap! send-queue
                    (fn [prev]
                      (p/then prev
                              (fn [_]
-                               (when-let [ws (:ws (get @worker-state/*worker-sync-clients repo))]
+                               (when-let [ws (:ws (get @worker-state/*db-sync-clients repo))]
                                  (when (ws-open? ws)
                                    (flush-pending! repo client)))))))))))))
 
@@ -605,7 +605,7 @@
   [repo {:keys [tx-data tx-meta] :as tx-report}]
   (when (and (enabled?) (seq tx-data) (not (:rtc-tx? tx-meta)))
     (enqueue-local-tx! repo tx-report)
-    (let [client (get @worker-state/*worker-sync-clients repo)]
+    (let [client (get @worker-state/*db-sync-clients repo)]
       (enqueue-asset-sync! repo client))))
 
 (defn- fetch-kvs-rows
@@ -619,7 +619,7 @@
   (let [base (http-base-url)
         graph-id (get-graph-id repo)]
     (if-not (and (seq base) (seq graph-id))
-      (p/rejected (ex-info "worker-sync missing upload info"
+      (p/rejected (ex-info "db-sync missing upload info"
                            {:repo repo :base base :graph-id graph-id}))
       (if-let [db (worker-state/get-sqlite-conn repo :db)]
         (do
@@ -643,5 +643,5 @@
                                                 #js {:reset first-batch?
                                                      :rows rows})})]
                     (p/recur max-addr false)))))))
-        (p/rejected (ex-info "worker-sync missing sqlite db"
+        (p/rejected (ex-info "db-sync missing sqlite db"
                              {:repo repo :graph-id graph-id}))))))

src/main/frontend/worker/db_worker.cljs

@@ -34,7 +34,7 @@
             [frontend.worker.shared-service :as shared-service]
             [frontend.worker.state :as worker-state]
             [frontend.worker.thread-atom]
-            [frontend.worker.worker-sync :as worker-sync]
+            [frontend.worker.db-sync :as db-sync]
             [goog.object :as gobj]
             [lambdaisland.glogi :as log]
             [lambdaisland.glogi.console :as glogi-console]
@@ -68,7 +68,7 @@
 (defonce *client-ops-conns worker-state/*client-ops-conns)
 (defonce *opfs-pools worker-state/*opfs-pools)
 (defonce *publishing? (atom false))
-(defonce *worker-sync-import-dbs (atom {}))
+(defonce *db-sync-import-dbs (atom {}))
 
 (defn- check-worker-scope!
   []
@@ -135,12 +135,12 @@
   (.exec db "PRAGMA locking_mode=exclusive")
   (.exec db "PRAGMA journal_mode=WAL"))
 
-(defn- ensure-worker-sync-import-db!
+(defn- ensure-db-sync-import-db!
   [repo reset?]
   (p/let [^js pool (<get-opfs-pool repo)
-          ^js db (or (get @*worker-sync-import-dbs repo)
+          ^js db (or (get @*db-sync-import-dbs repo)
                      (let [^js db (new (.-OpfsSAHPoolDb pool) repo-path)]
-                       (swap! *worker-sync-import-dbs assoc repo db)
+                       (swap! *db-sync-import-dbs assoc repo db)
                        db))]
     (enable-sqlite-wal-mode! db)
     (common-sqlite/create-kvs-table! db)
@@ -224,7 +224,7 @@
    ((@thread-api/*thread-apis :thread-api/create-or-open-db) repo
                                                              {:close-other-db? false
                                                               :datoms datoms
-                                                              :worker-sync-download-graph? true})
+                                                              :db-sync-download-graph? true})
    ((@thread-api/*thread-apis :thread-api/export-db) repo)
    (shared-service/broadcast-to-clients! :add-repo {:repo repo})))
 
@@ -323,7 +323,7 @@
                 (client-op/add-ops! repo client-ops))))
 
           (when initial-tx-report
-            (worker-sync/handle-local-tx! repo initial-tx-report))
+            (db-sync/handle-local-tx! repo initial-tx-report))
 
           (db-listener/listen-db-changes! repo (get @*datascript-conns repo)))))))
 
@@ -412,22 +412,22 @@
   (reset! worker-state/*rtc-ws-url rtc-ws-url)
   (init-sqlite-module!))
 
-(def-thread-api :thread-api/set-worker-sync-config
+(def-thread-api :thread-api/set-db-sync-config
   [config]
-  (reset! worker-state/*worker-sync-config config)
+  (reset! worker-state/*db-sync-config config)
   nil)
 
-(def-thread-api :thread-api/worker-sync-start
+(def-thread-api :thread-api/db-sync-start
   [repo]
-  (worker-sync/start! repo))
+  (db-sync/start! repo))
 
-(def-thread-api :thread-api/worker-sync-stop
+(def-thread-api :thread-api/db-sync-stop
   []
-  (worker-sync/stop!))
+  (db-sync/stop!))
 
-(def-thread-api :thread-api/worker-sync-upload-graph
+(def-thread-api :thread-api/db-sync-upload-graph
   [repo]
-  (worker-sync/upload-graph! repo))
+  (db-sync/upload-graph! repo))
 
 (def-thread-api :thread-api/set-infer-worker-proxy
   [infer-worker-proxy]
@@ -597,25 +597,25 @@
   (reset-db! repo db-transit)
   nil)
 
-(def-thread-api :thread-api/worker-sync-reset-from-datoms
+(def-thread-api :thread-api/db-sync-reset-from-datoms
   [repo datoms]
   (reset-db-from-datoms! repo datoms)
   nil)
 
-(def-thread-api :thread-api/worker-sync-import-kvs-rows
+(def-thread-api :thread-api/db-sync-import-kvs-rows
   [repo rows reset?]
   (p/let [_ (when reset?
               (close-db! repo))
-          db (ensure-worker-sync-import-db! repo reset?)]
+          db (ensure-db-sync-import-db! repo reset?)]
     (when (seq rows)
       (upsert-addr-content! db (rows->sqlite-binds rows)))
     nil))
 
-(def-thread-api :thread-api/worker-sync-finalize-kvs-import
+(def-thread-api :thread-api/db-sync-finalize-kvs-import
   [repo remote-tx]
-  (p/let [^js db (get @*worker-sync-import-dbs repo)]
+  (p/let [^js db (get @*db-sync-import-dbs repo)]
     (.close db)
-    (swap! *worker-sync-import-dbs dissoc repo)
+    (swap! *db-sync-import-dbs dissoc repo)
     ((@thread-api/*thread-apis :thread-api/create-or-open-db) repo {:close-other-db? true})
     ((@thread-api/*thread-apis :thread-api/export-db) repo)
     (client-op/update-local-tx repo remote-tx)

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

@@ -98,8 +98,8 @@
    ;; local-tx is the latest remote-tx that local db persists
    :local-tx {:db/index true}
    :graph-uuid {:db/index true}
-   :worker-sync/tx-id {:db/unique :db.unique/identity}
-   :worker-sync/created-at {:db/index true}})
+   :db-sync/tx-id {:db/unique :db.unique/identity}
+   :db-sync/created-at {:db/index true}})
 
 (defn update-graph-uuid
   [repo graph-uuid]

src/main/frontend/worker/state.cljs

@@ -46,8 +46,8 @@
                        :thread-atom/online-event (atom nil)}))
 
 (defonce *rtc-ws-url (atom nil))
-(defonce *worker-sync-config (atom {:enabled? false :ws-url nil}))
-(defonce *worker-sync-clients (atom {}))
+(defonce *db-sync-config (atom {:enabled? false :ws-url nil}))
+(defonce *db-sync-clients (atom {}))
 
 (defonce *sqlite (atom nil))
 ;; repo -> {:db conn :search conn :client-ops conn :debug-log conn}