enhance: add logseq.common.defkeywords

.clj-kondo/config.edn

@@ -12,6 +12,7 @@
 
  :linters
  {:path-invalid-construct/string-join {:level :info}
+  :defkeywords/invalid-arg {:level :warning}
   :regex-checks/double-escaped-regex {:level :warning}
   :aliased-namespace-symbol {:level :warning}
   :shadowed-var {:level :warning
@@ -204,7 +205,8 @@
  :hooks {:analyze-call {rum.core/defc hooks.rum/defc
                         rum.core/defcs hooks.rum/defcs
                         clojure.string/join hooks.path-invalid-construct/string-join
-                        clojure.string/replace hooks.regex-checks/double-escaped-regex}}
+                        clojure.string/replace hooks.regex-checks/double-escaped-regex
+                        logseq.common.defkeywords/defkeywords hooks.defkeywords/defkeywords}}
  :lint-as {promesa.core/let clojure.core/let
            promesa.core/loop clojure.core/loop
            promesa.core/recur clojure.core/recur
@@ -220,7 +222,7 @@
            frontend.test.helper/deftest-async clojure.test/deftest
            frontend.worker.rtc.idb-keyval-mock/with-reset-idb-keyval-mock cljs.test/async
            frontend.react/defc clojure.core/defn
-           frontend.common.schema-register/defkeyword cljs.spec.alpha/def}
+           logseq.common.defkeywords/defkeyword cljs.spec.alpha/def}
  :skip-comments true
  :output {:progress true
           :exclude-files ["src/test/docs-0.10.9/"]}}

.clj-kondo/hooks/defkeywords.clj

@@ -0,0 +1,29 @@
+(ns hooks.defkeywords
+  (:require [clj-kondo.hooks-api :as api]))
+
+(defn defkeywords
+  [{:keys [node]}]
+  (let [[_ & keyvals] (:children node)
+        kw->v (partition 2 keyvals)
+        kws (map first kw->v)]
+    (cond
+      (odd? (count keyvals))
+      (api/reg-finding!
+       (assoc (meta node)
+              :message "Require even number of args"
+              :type :defkeywords/invalid-arg))
+      (not (every? (comp qualified-keyword? api/sexpr) kws))
+      (api/reg-finding!
+       (assoc (meta node)
+              :message "Should use qualified-keywords"
+              :type :defkeywords/invalid-arg))
+      :else
+      (let [new-node (api/list-node
+                      (map (fn [k]
+                             (api/list-node
+                              [(api/token-node 'logseq.common.defkeywords/defkeyword)
+                               k
+                               (api/token-node "")]))
+                           kws))]
+        {:node (with-meta new-node
+                 (meta node))}))))

deps/common/src/logseq/common/defkeywords.cljc

@@ -0,0 +1,19 @@
+(ns logseq.common.defkeywords
+  "Macro 'defkeywords' to def keyword with docstring"
+  #?(:cljs (:require-macros [logseq.common.defkeywords])))
+
+#_:clj-kondo/ignore
+(defmacro defkeyword
+  "Define keyword with docstring.
+  How 'find keyword definition' works?
+  clojure-lsp treat keywords defined by `cljs.spec.alpha/def` as keyword-definition.
+  Adding a :lint-as `defkeyword` -> `cljs.spec.alpha/def` in clj-kondo config make it works."
+  [kw docstring & _args]
+  (assert (keyword? kw) "must be keyword")
+  (assert (some? docstring) "must have 'docstring' arg"))
+
+(defmacro defkeywords
+  "impl at hooks.defkeywords in .clj-kondo
+(defkeywords ::a <config-map> ::b <config-map>)"
+  [& keyvals]
+  `(vector ~@keyvals))

src/main/frontend/common/schema_register.clj

@@ -1,15 +0,0 @@
-(ns frontend.common.schema-register
-  "Macro 'defkeyword' to def keyword with docstring and malli-schema.
-   Used by frontend and worker namespaces")
-
-(defmacro defkeyword
-  "Define keyword with docstring and malli-schema.
-  How 'find keyword definition' works?
-  clojure-lsp treat keywords defined by `cljs.spec.alpha/def` as keyword-definition.
-  Adding a :lint-as `defkeyword` -> `cljs.spec.alpha/def` in clj-kondo config make it works."
-  [kw docstring & [optional-malli-schema]]
-  (assert (keyword? kw) "must be keyword")
-  (assert (some? docstring) "must have 'docstring' arg")
-  (when optional-malli-schema
-    `(do (assert (frontend.common.schema-register/not-register-yet? ~kw) (str "Already registered: " ~kw))
-         (frontend.common.schema-register/register! ~kw ~optional-malli-schema))))

src/main/frontend/common/schema_register.cljs

@@ -1,23 +0,0 @@
-(ns frontend.common.schema-register
-  "Set malli default registry to a mutable one,
-  and use `register!` to add schemas dynamically."
-  (:require [malli.core :as m]
-            [malli.registry :as mr]))
-
-(def *malli-registry (atom {}))
-
-(defn register!
-  [type schema]
-  (swap! *malli-registry assoc type schema))
-
-(defn not-register-yet?
-  [type]
-  (boolean (nil? (@*malli-registry type))))
-
-(defn init
-  []
-  (reset! *malli-registry {})
-  (mr/set-default-registry!
-   (mr/composite-registry
-    (m/default-schemas)
-    (mr/mutable-registry *malli-registry))))

src/main/frontend/common_keywords.cljs

@@ -1,50 +1,15 @@
 (ns frontend.common-keywords
   "There are some keywords scattered throughout the codebase."
-  (:require [frontend.common.schema-register :include-macros true :as sr]))
-
-(sr/defkeyword :block/uuid
-  "block's uuid"
-  :uuid)
-
-(sr/defkeyword :block/name
-  "block name, lowercase, only page-blocks have this attr"
-  :string)
-
-(sr/defkeyword :block/type
-  "block type"
-  [:enum "page" "property" "class" "whiteboard"])
-
-(sr/defkeyword :block/parent
-  "page blocks don't have this attr")
-
-(sr/defkeyword :block/order
-  "
-- page blocks don't have this attr
-- some no-order blocks don't have this attr too,
-  TODO: list these types")
-
-(sr/defkeyword :block/title
-  "Title or content string of the blocks.
-in db-version, page-references(e.g. [[page-name]]) are stored as [[uuid]]."
-  :string)
-
-(sr/defkeyword :block/raw-title
-  "like `:block/title`,
-but when eval `(:block/raw-title block-entity)`, return raw title of this block"
-  :string)
-
-(sr/defkeyword :kv/value
-  "Used to store key-value, the value could be anything, e.g. {:db/ident :logseq.kv/xxx :kv/value value}"
-  :any)
-
-(sr/defkeyword :logseq.property/parent
-  "A class's parent class")
-
-(sr/defkeyword :logseq.property.class/properties
-  "Class properties that all of its objects can use, notice that it's different from this class's own properties.")
-
-(sr/defkeyword :block/closed-value-property
-  "The property that this closed value (an Entity) belongs to.")
-
-(sr/defkeyword :property/schema.classes
-  "The classes that this property value must to sastify (being an object of a class)")
+  (:require [logseq.common.defkeywords :refer [defkeywords]]))
+
+(defkeywords
+  :block/uuid      {:doc "block's uuid"}
+  :block/name      {:doc "block name, lowercase, only page-blocks have this attr"}
+  :block/type      {:doc "block type, *deprecated* in db-version"}
+  :block/parent    {:doc "page blocks don't have this attr"}
+  :block/order     {:doc "- page blocks don't have this attr
+                          - some no-order blocks don't have this attr too"}
+  :block/raw-title {:doc "like `:block/title`,
+                          but when eval `(:block/raw-title block-entity)`, return raw title of this block"}
+  :kv/value        {:doc "Used to store key-value, the value could be anything,
+                          e.g. {:db/ident :logseq.kv/xxx :kv/value value}"})

src/main/frontend/core.cljs

@@ -3,7 +3,6 @@
   {:dev/always true}
   (:require [frontend.background-tasks]
             [frontend.common-keywords]
-            [frontend.common.schema-register :as sr]
             [frontend.components.plugins :as plugins]
             [frontend.config :as config]
             [frontend.fs.sync :as sync]
@@ -50,7 +49,6 @@
 (defn ^:export start []
   (when config/dev?
     (md/start!))
-  (frontend.common.schema-register/init)
   (when-let [node (.getElementById js/document "root")]
     (set-router!)
     (rum/mount (page/current-page) node)

src/main/frontend/worker/db_listener.cljs

@@ -2,7 +2,6 @@
   "Db listeners for worker-db."
   (:require [cljs-bean.core :as bean]
             [datascript.core :as d]
-            [frontend.common.schema-register :as sr]
             [frontend.worker.pipeline :as worker-pipeline]
             [frontend.worker.search :as search]
             [frontend.worker.state :as worker-state]
@@ -14,21 +13,6 @@
 (defmulti listen-db-changes
   (fn [listen-key & _] listen-key))
 
-(sr/defkeyword :gen-rtc-ops
-  "DB-listener key.
-generate rtc ops.")
-
-(sr/defkeyword :gen-undo-ops
-  "DB-listener key.
-generate undo ops.")
-
-(sr/defkeyword :gen-asset-change-events
-  "DB-listener key.
-generate asset-change events.")
-
-(sr/defkeyword :sync-db-to-main-thread
-  "")
-
 (defn- sync-db-to-main-thread
   "Return tx-report"
   [repo conn {:keys [tx-meta] :as tx-report}]

src/main/frontend/worker/pipeline.cljs

@@ -1,19 +1,19 @@
 (ns frontend.worker.pipeline
   "Pipeline work after transaction"
   (:require [datascript.core :as d]
-            [frontend.common.schema-register :as sr]
+            [frontend.worker.commands :as commands]
             [frontend.worker.file :as file]
             [frontend.worker.react :as worker-react]
             [frontend.worker.state :as worker-state]
             [frontend.worker.util :as worker-util]
+            [logseq.common.defkeywords :refer [defkeywords]]
             [logseq.db :as ldb]
             [logseq.db.frontend.validate :as db-validate]
-            [logseq.graph-parser.exporter :as gp-exporter]
             [logseq.db.sqlite.util :as sqlite-util]
+            [logseq.graph-parser.exporter :as gp-exporter]
             [logseq.outliner.core :as outliner-core]
             [logseq.outliner.datascript-report :as ds-report]
-            [logseq.outliner.pipeline :as outliner-pipeline]
-            [frontend.worker.commands :as commands]))
+            [logseq.outliner.pipeline :as outliner-pipeline]))
 
 (defn- refs-need-recalculated?
   [tx-meta]
@@ -45,13 +45,14 @@
                            :block/refs refs})))))
             blocks)))
 
-(sr/defkeyword :skip-validate-db?
-  "tx-meta option, default = false")
+(defkeywords
+  ::skip-validate-db? {:doc "tx-meta option, default = false"}
+  ::skip-store-conn {:doc "tx-meta option, skip `d/store` on conn. default = false"})
 
 (defn validate-db!
   "Validate db is slow, we probably don't want to enable it for production."
   [repo conn tx-report tx-meta context]
-  (when (and (not (:skip-validate-db? tx-meta false))
+  (when (and (not (::skip-validate-db? tx-meta false))
              (:dev? context)
              (not (:importing? context)) (sqlite-util/db-based-graph? repo))
     (let [valid? (if (get-in tx-report [:tx-meta :reset-conn!])
@@ -72,10 +73,6 @@
               (assert (= (count (distinct (map :block/order children))) (count children))
                       (str ":block/order is not unique for children blocks, parent id: " (:db/id parent))))))))))
 
-(sr/defkeyword :skip-store-conn
-  "tx-meta option, skip `d/store` on conn.
-default = false")
-
 (defn- add-missing-properties-to-typed-display-blocks
   "Add missing properties for these cases:
   1. Add corresponding tag when invoking commands like /code block.
@@ -166,7 +163,7 @@ default = false")
                        (ldb/transact! conn replace-tx {:pipeline-replace? true})
                        (do
                          (when-not (or (exists? js/process)
-                                       (:skip-store-conn tx-meta false))
+                                       (::skip-store-conn tx-meta false))
                            (d/store @conn))
                          tx-report*))
           _ (validate-db! repo conn tx-report* tx-meta context)
@@ -201,7 +198,7 @@ default = false")
                             (ldb/transact! conn path-refs {:pipeline-replace? true}))
                           (do
                             (when-not (or (exists? js/process)
-                                          (:skip-store-conn tx-meta false))
+                                          (::skip-store-conn tx-meta false))
                               (d/store @conn))
                             tx-report))
               full-tx-data (concat (:tx-data tx-report) (:tx-data tx-report'))

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

@@ -2,7 +2,6 @@
   "listen datascript changes, infer operations from the db tx-report"
   (:require [clojure.string :as string]
             [datascript.core :as d]
-            [frontend.common.schema-register :include-macros true :as sr]
             [frontend.worker.db-listener :as db-listener]
             [frontend.worker.rtc.client-op :as client-op]
             [logseq.db :as ldb]
@@ -120,8 +119,10 @@
     (when (seq ops)
       (client-op/add-ops repo ops))))
 
-(sr/defkeyword :persist-op?
-  "tx-meta option, generate rtc ops when not nil (default true)")
+(comment
+  ;; TODO: make it a qualified-keyword
+  (defkeywords
+    :persist-op? {:doc "tx-meta option, generate rtc ops when not nil (default true)"}))
 
 (defn- entity-datoms=>a->add?->v->t
   [entity-datoms]

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

@@ -1,43 +1,26 @@
 (ns frontend.worker.rtc.exception
   "Exception list"
-  (:require [frontend.common.schema-register :include-macros true :as sr]))
-
-(sr/defkeyword :rtc.exception/remote-graph-not-exist
-  "Remote exception. e.g. push client-updates to a deleted graph.")
-
-(sr/defkeyword :rtc.exception/remote-graph-not-ready
-  "Remote exception. Remote graph is still creating.")
-
-(sr/defkeyword :rtc.exception/remote-graph-lock-missing
-  "Remote exception. Failed to remote graph lock isn't exist.
-It's a server internal error, shouldn't happen.")
-
-(sr/defkeyword :rtc.exception/not-rtc-graph
-  "Local exception. Trying to start rtc loop on a local-graph.")
-
-(sr/defkeyword :rtc.exception/lock-failed
-  "Local exception.
-Trying to start rtc loop but there's already one running, need to cancel that one first.")
-
-(sr/defkeyword :rtc.exception/not-found-db-conn
-  "Local exception. Cannot find db-conn by repo")
-
-(sr/defkeyword :rtc.exception/get-s3-object-failed
-  "Failed to fetch response from s3.
+  (:require [logseq.common.defkeywords :refer [defkeywords]]))
+
+(defkeywords
+  :rtc.exception/remote-graph-not-exist {:doc "Remote exception. e.g. push client-updates to a deleted graph."}
+  :rtc.exception/remote-graph-not-ready {:doc "Remote exception. Remote graph is still creating."}
+  :rtc.exception/remote-graph-lock-missing {:doc "
+Remote exception. Failed to remote graph lock isn't exist.
+It's a server internal error, shouldn't happen."}
+  :rtc.exception/not-rtc-graph {:doc "Local exception. Trying to start rtc loop on a local-graph."}
+  :rtc.exception/lock-failed {:doc "
+Local exception.
+Trying to start rtc loop but there's already one running, need to cancel that one first."}
+  :rtc.exception/not-found-db-conn {:doc "Local exception. Cannot find db-conn by repo"}
+  :rtc.exception/get-s3-object-failed {:doc "
+Failed to fetch response from s3.
 When response from remote is too huge(> 32KB),
-the server will put it to s3 and return its presigned-url to clients.")
-
-(sr/defkeyword :rtc.exception/different-graph-skeleton
-  "remote graph skeleton data is different from local's.")
-
-(sr/defkeyword :rtc.exception/bad-request-body
-  "bad request body, rejected by server-schema")
-
-(sr/defkeyword :rtc.exception/not-allowed
-  "this api-call is not allowed")
-
-(sr/defkeyword :rtc.exception/ws-timeout
-  "websocket timeout")
+the server will put it to s3 and return its presigned-url to clients."}
+  :rtc.exception/different-graph-skeleton {:doc "remote graph skeleton data is different from local's."}
+  :rtc.exception/bad-request-body {:doc "bad request body, rejected by server-schema"}
+  :rtc.exception/not-allowed {:doc "this api-call is not allowed"}
+  :rtc.exception/ws-timeout {:doc "websocket timeout"})
 
 (def ex-remote-graph-not-exist
   (ex-info "remote graph not exist" {:type :rtc.exception/remote-graph-not-exist}))

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

@@ -209,7 +209,7 @@
                           :block/refs refs})))
                    datoms)]
       (ldb/transact! conn refs-tx (cond-> {:outliner-op :rtc-download-rebuild-block-refs}
-                                    rtc-const/RTC-E2E-TEST (assoc :skip-store-conn true))))))
+                                    rtc-const/RTC-E2E-TEST (assoc :frontend.worker.pipeline/skip-store-conn true))))))
 
 (defn- block->schema-map
   [block]
@@ -239,17 +239,18 @@
   (let [conn (d/create-conn db-schema/schema-for-db-based-graph)
         db-initial-data (sqlite-create-graph/build-db-initial-data "")]
     (swap! worker-state/*datascript-conns assoc repo conn)
-    (d/transact! conn db-initial-data {:initial-db? true :skip-store-conn rtc-const/RTC-E2E-TEST})
+    (d/transact! conn db-initial-data {:initial-db? true
+                                       :frontend.worker.pipeline/skip-store-conn rtc-const/RTC-E2E-TEST})
     (db-listener/listen-db-changes! repo conn)
     (d/transact! conn init-tx-data {:rtc-download-graph? true
                                     :gen-undo-ops? false
                                     ;; only transact db schema, skip validation to avoid warning
-                                    :skip-validate-db? true
-                                    :skip-store-conn rtc-const/RTC-E2E-TEST
+                                    :frontend.worker.pipeline/skip-validate-db? true
+                                    :frontend.worker.pipeline/skip-store-conn rtc-const/RTC-E2E-TEST
                                     :persist-op? false})
     (d/transact! conn other-tx-data {:rtc-download-graph? true
                                      :gen-undo-ops? false
-                                     :skip-store-conn rtc-const/RTC-E2E-TEST
+                                     :frontend.worker.pipeline/skip-store-conn rtc-const/RTC-E2E-TEST
                                      :persist-op? false})
     (transact-block-refs! repo)))
 
@@ -314,7 +315,7 @@
           (.transact worker-obj repo init-tx-data {:rtc-download-graph? true
                                                    :gen-undo-ops? false
                                                      ;; only transact db schema, skip validation to avoid warning
-                                                   :skip-validate-db? true
+                                                   :frontend.worker.pipeline/skip-validate-db? true
                                                    :persist-op? false} (worker-state/get-context))
           (.transact worker-obj repo tx-data {:rtc-download-graph? true
                                               :gen-undo-ops? false

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

@@ -1,8 +1,8 @@
 (ns frontend.worker.rtc.log-and-state
   "Fns to generate rtc related logs"
-  (:require [frontend.common.schema-register :as sr]
+  (:require [frontend.common.missionary :as c.m]
             [frontend.worker.util :as worker-util]
-            [frontend.common.missionary :as c.m]
+            [logseq.common.defkeywords :refer [defkeywords]]
             [malli.core :as ma]
             [missionary.core :as m]))
 
@@ -12,11 +12,9 @@
   "used by rtc-e2e-test"
   (m/watch *rtc-log))
 
-(sr/defkeyword :rtc.log/upload
-  "rtc log type for upload-graph.")
-
-(sr/defkeyword :rtc.log/download
-  "rtc log type for upload-graph.")
+(defkeywords
+  :rtc.log/upload {:doc "rtc log type for upload-graph."}
+  :rtc.log/download {:doc "rtc log type for upload-graph."})
 
 (def ^:private rtc-log-type-schema
   [:enum

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

@@ -4,7 +4,7 @@
             [clojure.set :as set]
             [clojure.string :as string]
             [datascript.core :as d]
-            [frontend.common.schema-register :as sr]
+            [logseq.common.defkeywords :refer [defkeywords]]
             [frontend.worker.handler.page :as worker-page]
             [frontend.worker.rtc.asset :as r.asset]
             [frontend.worker.rtc.client-op :as client-op]
@@ -23,9 +23,10 @@
             [logseq.outliner.core :as outliner-core]
             [logseq.outliner.transaction :as outliner-tx]))
 
-(sr/defkeyword ::need-pull-remote-data
-  "remote-update's :remote-t-before > :local-tx,
-   so need to pull earlier remote-data from websocket.")
+(defkeywords
+  ::need-pull-remote-data {:doc "
+remote-update's :remote-t-before > :local-tx,
+so need to pull earlier remote-data from websocket."})
 
 (defmulti ^:private transact-db! (fn [action & _args] action))
 
@@ -593,7 +594,7 @@
           (batch-tx/with-batch-tx-mode conn {:rtc-tx? true
                                              :persist-op? false
                                              :gen-undo-ops? false
-                                             :skip-store-conn rtc-const/RTC-E2E-TEST}
+                                             :frontend.worker.pipeline/skip-store-conn rtc-const/RTC-E2E-TEST}
             (worker-util/profile :ensure-refed-blocks-exist (ensure-refed-blocks-exist repo conn refed-blocks))
             (worker-util/profile :apply-remote-update-page-ops (apply-remote-update-page-ops repo conn update-page-ops))
             (worker-util/profile :apply-remote-move-ops (apply-remote-move-ops repo conn sorted-move-ops))

src/main/frontend/worker/state.cljs

@@ -1,14 +1,12 @@
 (ns frontend.worker.state
   "State hub for worker"
-  (:require [logseq.common.util :as common-util]
-            [logseq.common.config :as common-config]
-            [frontend.common.schema-register :include-macros true :as sr]))
+  (:require [logseq.common.config :as common-config]
+            [logseq.common.defkeywords :refer [defkeywords]]
+            [logseq.common.util :as common-util]))
 
-(sr/defkeyword :undo/repo->page-block-uuid->undo-ops
-  "{repo {<page-block-uuid> [op1 op2 ...]}}")
-
-(sr/defkeyword :undo/repo->page-block-uuid->redo-ops
-  "{repo {<page-block-uuid> [op1 op2 ...]}}")
+(defkeywords
+  :undo/repo->page-block-uuid->undo-ops {:doc "{repo {<page-block-uuid> [op1 op2 ...]}}"}
+  :undo/repo->page-block-uuid->redo-ops {:doc "{repo {<page-block-uuid> [op1 op2 ...]}}"})
 
 (defonce *main-thread (atom nil))
 

src/main/frontend/worker/undo_redo.cljs

@@ -2,55 +2,57 @@
   "undo/redo related fns and op-schema"
   (:require [clojure.set :as set]
             [datascript.core :as d]
-            [frontend.common.schema-register :include-macros true :as sr]
-            [logseq.outliner.batch-tx :include-macros true :as batch-tx]
             [frontend.worker.db-listener :as db-listener]
             [frontend.worker.state :as worker-state]
             [logseq.common.config :as common-config]
             [logseq.common.util :as common-util]
+            [logseq.db :as ldb]
+            [logseq.outliner.batch-tx :include-macros true :as batch-tx]
             [logseq.outliner.core :as outliner-core]
             [logseq.outliner.transaction :as outliner-tx]
-            [logseq.db :as ldb]
             [malli.core :as m]
             [malli.util :as mu]))
+(comment
+  ;; this ns is not used currently, so just comment out these kw definitions
+  ;; use logseq.common.defkeywords/defkeywords instead
 
-(sr/defkeyword :gen-undo-ops?
-  "tx-meta option, generate undo ops from tx-data when true (default true)")
+  (sr/defkeyword :gen-undo-ops?
+    "tx-meta option, generate undo ops from tx-data when true (default true)")
 
-(sr/defkeyword :gen-undo-boundary-op?
-  "tx-meta option, generate `::boundary` undo-op when true (default true).
+  (sr/defkeyword :gen-undo-boundary-op?
+    "tx-meta option, generate `::boundary` undo-op when true (default true).
 usually every transaction's tx-data will generate ops like: [<boundary> <op1> <op2> ...],
 push to undo-stack, result in [...<boundary> <op0> <boundary> <op1> <op2> ...].
 
 when this option is false, only generate [<op1> <op2> ...]. undo-stack: [...<boundary> <op0> <op1> <op2> ...]
 so when undo, it will undo [<op0> <op1> <op2>] instead of [<op1> <op2>]")
 
-(sr/defkeyword ::boundary
-  "boundary of one or more undo-ops.
+  (sr/defkeyword ::boundary
+    "boundary of one or more undo-ops.
 when one undo/redo will operate on all ops between two ::boundary")
 
-(sr/defkeyword ::insert-blocks
-  "when some blocks are inserted, generate a ::insert-blocks undo-op.
+  (sr/defkeyword ::insert-blocks
+    "when some blocks are inserted, generate a ::insert-blocks undo-op.
 when undo this op, the related blocks will be removed.")
 
-(sr/defkeyword ::move-block
-  "when a block is moved, generate a ::move-block undo-op.")
+  (sr/defkeyword ::move-block
+    "when a block is moved, generate a ::move-block undo-op.")
 
-(sr/defkeyword ::remove-block
-  "when a block is removed, generate a ::remove-block undo-op.
+  (sr/defkeyword ::remove-block
+    "when a block is removed, generate a ::remove-block undo-op.
 when undo this op, this original entity-map will be transacted back into db")
 
-(sr/defkeyword ::update-block
-  "when a block is updated, generate a ::update-block undo-op.")
+  (sr/defkeyword ::update-block
+    "when a block is updated, generate a ::update-block undo-op.")
 
-(sr/defkeyword ::record-editor-info
-  "record current editor and cursor")
+  (sr/defkeyword ::record-editor-info
+    "record current editor and cursor")
 
-(sr/defkeyword ::empty-undo-stack
-  "return by undo, when no more undo ops")
+  (sr/defkeyword ::empty-undo-stack
+    "return by undo, when no more undo ops")
 
-(sr/defkeyword ::empty-redo-stack
-  "return by redo, when no more redo ops")
+  (sr/defkeyword ::empty-redo-stack
+    "return by redo, when no more redo ops"))
 
 (def ^:private boundary [::boundary])
 

src/main/frontend/worker/undo_redo2.cljs

@@ -1,26 +1,24 @@
 (ns frontend.worker.undo-redo2
   "Undo redo new implementation"
-  (:require [datascript.core :as d]
+  (:require [clojure.set :as set]
+            [datascript.core :as d]
             [frontend.worker.db-listener :as db-listener]
             [frontend.worker.state :as worker-state]
-            [clojure.set :as set]
-            [frontend.common.schema-register :include-macros true :as sr]
+            [logseq.common.defkeywords :refer [defkeywords]]
+            [logseq.db :as ldb]
             [malli.core :as m]
-            [malli.util :as mu]
-            [logseq.db :as ldb]))
+            [malli.util :as mu]))
 
-;; TODO: add other UI states such as `::ui-updates`.
-(sr/defkeyword :gen-undo-ops?
-  "tx-meta option, generate undo ops from tx-data when true (default true)")
-
-(sr/defkeyword ::record-editor-info
-  "record current editor and cursor")
-
-(sr/defkeyword ::db-transact
-  "db tx")
+(defkeywords
+  ::record-editor-info {:doc "record current editor and cursor"}
+  ::db-transact {:doc "db tx"}
+  ::ui-state {:doc "ui state such as route && sidebar blocks"})
 
-(sr/defkeyword ::ui-state
-  "ui state such as route && sidebar blocks")
+;; TODO: add other UI states such as `::ui-updates`.
+(comment
+  ;; TODO: convert it to a qualified-keyword
+  (sr/defkeyword :gen-undo-ops?
+    "tx-meta option, generate undo ops from tx-data when true (default true)"))
 
 (def ^:private undo-op-item-schema
   (mu/closed-schema

src/rtc_e2e_test/helper.cljs

@@ -132,7 +132,7 @@
                     :block/page "page"
                     :block/updated-at 1724836490810
                     :block/created-at 1724836490810}]]
-      (batch-tx/with-batch-tx-mode conn {:e2e-test const/downloaded-test-repo :skip-store-conn true}
+      (batch-tx/with-batch-tx-mode conn {:e2e-test const/downloaded-test-repo :frontend.worker.pipeline/skip-store-conn true}
         (d/transact! conn tx-data))
       (m/? (new-task--wait-all-client-ops-sent))
       (log :sent-message message))))
@@ -184,7 +184,7 @@
 (defn transact!
   [conn tx-data]
   {:pre [(seq tx-data)]}
-  (batch-tx/with-batch-tx-mode conn {:e2e-test const/downloaded-test-repo :skip-store-conn true}
+  (batch-tx/with-batch-tx-mode conn {:e2e-test const/downloaded-test-repo :frontend.worker.pipeline/skip-store-conn true}
     (d/transact! conn tx-data)))
 
 (def new-task--stop-rtc