feat: reactions

Author: tiensonqin

AGENTS.md

@@ -35,3 +35,5 @@
 - Review notes live in `prompts/review.md`; check them when preparing changes.
 - 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`.
+- New properties should be added to `logseq.db.frontend.property/built-in-properties`.
+- Avoid creating new class or property unless you have to.

deps/db/src/logseq/db/common/delete_blocks.cljs

@@ -56,6 +56,11 @@
                                            (not (entity-util/page? (d/entity db id))))))]
     (when (seq retracted-block-ids)
       (let [retracted-blocks (map #(d/entity db %) retracted-block-ids)
+            reaction-entities (->> retracted-blocks
+                                   (mapcat :logseq.property.reaction/_target)
+                                   (common-util/distinct-by :db/id))
+            retract-reactions-tx (map (fn [reaction] [:db/retractEntity (:db/id reaction)])
+                                      reaction-entities)
             retracted-tx (build-retracted-tx retracted-blocks)
             retract-history-tx (mapcat (fn [e]
                                          (map (fn [history] [:db/retractEntity (:db/id history)])
@@ -67,4 +72,4 @@
                                (:logseq.property/_view-for block)))
                            retracted-blocks)
                           (map (fn [b] [:db/retractEntity (:db/id b)])))]
-        (concat retracted-tx delete-views retract-history-tx)))))
+        (concat retracted-tx delete-views retract-history-tx retract-reactions-tx)))))

deps/db/src/logseq/db/frontend/malli_schema.cljs

@@ -126,7 +126,9 @@
    #{:logseq.property/created-from-property :logseq.property/value
      :logseq.property.history/scalar-value :logseq.property.history/block
      :logseq.property.history/property :logseq.property.history/ref-value
-     :logseq.property.class/extends}))
+     :logseq.property.class/extends
+     :logseq.property.reaction/emoji-id
+     :logseq.property.reaction/target}))
 
 (defn- property-entity->map
   "Provide the minimal number of property attributes to validate the property
@@ -431,6 +433,16 @@
     (remove #(#{:block/title :logseq.property/created-from-property} (first %)) block-attrs)
     page-or-block-attrs)))
 
+(def reaction-entity
+  "A reaction entity referencing a target node"
+  (vec
+   [:map {:error/path ["reaction-entity"]}
+    [:logseq.property.reaction/emoji-id :string]
+    [:logseq.property.reaction/target :int]
+    [:logseq.property/created-by-ref {:optional true} :int]
+    [:block/created-at :int]
+    [:block/tx-id {:optional true} :int]]))
+
 (def property-history-block*
   [:map
    [:block/uuid :uuid]
@@ -540,6 +552,8 @@
   (let [d (if (:block/uuid ent) (d/entity db [:block/uuid (:block/uuid ent)]) ent)
         ;; order matters as some block types are a subset of others e.g. :whiteboard
         dispatch-key (cond
+                       (:logseq.property.reaction/target d)
+                       :reaction-entity
                        (entity-util/property? d)
                        :property
                        (entity-util/class? d)
@@ -576,6 +590,7 @@
     :class class-page
     :hidden hidden-page
     :normal-page normal-page
+    :reaction-entity reaction-entity
     :property-history-block property-history-block
     :closed-value-block closed-value-block
     :property-value-block property-value-block

deps/db/src/logseq/db/frontend/property.cljs

@@ -615,6 +615,14 @@
                                       :schema {:type :entity
                                                :hide? true}
                                       :queryable? true}
+     :logseq.property.reaction/emoji-id {:title "Reaction emoji"
+                                         :schema {:type :string
+                                                  :public? false
+                                                  :hide? true}}
+     :logseq.property.reaction/target {:title "Reaction target"
+                                       :schema {:type :node
+                                                :public? false
+                                                :hide? true}}
      :logseq.property/used-template {:title "Used template"
                                      :schema {:type :node
                                               :public? false
@@ -687,6 +695,7 @@
     "logseq.property.code" "logseq.property.repeat"
     "logseq.property.journal" "logseq.property.class" "logseq.property.view"
     "logseq.property.user" "logseq.property.history" "logseq.property.embedding"
+    "logseq.property.reaction"
     "logseq.property.publish"})
 
 (defn logseq-property?

deps/db/test/logseq/db/common/delete_blocks_test.cljs

@@ -0,0 +1,26 @@
+(ns logseq.db.common.delete-blocks-test
+  (:require [cljs.test :refer [deftest is testing]]
+            [datascript.core :as d]
+            [logseq.common.util :as common-util]
+            [logseq.db.common.delete-blocks :as delete-blocks]
+            [logseq.db.test.helper :as db-test]))
+
+(deftest delete-blocks-removes-reactions
+  (testing "reactions targeting deleted blocks are retracted"
+    (let [conn (db-test/create-conn-with-blocks
+                {:pages-and-blocks
+                 [{:page {:block/title "Page"}
+                   :blocks [{:block/title "Block"}]}]})
+          block (db-test/find-block-by-content @conn "Block")
+          now (common-util/time-ms)
+          reaction {:block/uuid (random-uuid)
+                    :block/created-at now
+                    :block/updated-at now
+                    :logseq.property.reaction/emoji-id "+1"
+                    :logseq.property.reaction/target (:db/id block)}
+          _ (d/transact! conn [reaction])
+          reaction-entity (first (:logseq.property.reaction/_target (d/entity @conn (:db/id block))))
+          retracts [[:db/retractEntity (:db/id block)]]
+          extra (delete-blocks/update-refs-history @conn retracts {})]
+      (d/transact! conn (concat retracts extra))
+      (is (nil? (d/entity @conn (:db/id reaction-entity)))))))

deps/db/test/logseq/db/frontend/property_test.cljs

@@ -43,3 +43,23 @@
           sorted-entities [p1 p2]
           tx-data (db-property/normalize-sorted-entities-block-order sorted-entities)]
       (is (empty? tx-data)))))
+
+(deftest reaction-built-in-properties
+  (let [props db-property/built-in-properties]
+    (testing "entries exist"
+      (is (contains? props :logseq.property.reaction/emoji-id))
+      (is (contains? props :logseq.property.reaction/target)))
+
+    (testing "schema types"
+      (is (= :string (get-in props [:logseq.property.reaction/emoji-id :schema :type])))
+      (is (= :node (get-in props [:logseq.property.reaction/target :schema :type]))))
+
+    (testing "internal visibility"
+      (is (= false (get-in props [:logseq.property.reaction/emoji-id :schema :public?])))
+      (is (= false (get-in props [:logseq.property.reaction/target :schema :public?])))
+      (is (= true (get-in props [:logseq.property.reaction/emoji-id :schema :hide?])))
+      (is (= true (get-in props [:logseq.property.reaction/target :schema :hide?]))))
+
+    (testing "logseq property namespace"
+      (is (db-property/logseq-property? :logseq.property.reaction/emoji-id))
+      (is (db-property/logseq-property? :logseq.property.reaction/target)))))

deps/db/test/logseq/db/frontend/reaction_test.cljs

@@ -0,0 +1,22 @@
+(ns logseq.db.frontend.reaction-test
+  (:require [cljs.test :refer [deftest is testing]]
+            [datascript.core :as d]
+            [logseq.common.util :as common-util]
+            [logseq.db.frontend.validate :as db-validate]
+            [logseq.db.test.helper :as db-test]))
+
+(deftest reaction-entity-valid
+  (testing "reaction entity passes db validation"
+    (let [conn (db-test/create-conn-with-blocks
+                {:pages-and-blocks
+                 [{:page {:block/title "Page"}
+                   :blocks [{:block/title "Block"}]}]})
+          block (db-test/find-block-by-content @conn "Block")
+          now (common-util/time-ms)
+          reaction {:block/uuid (random-uuid)
+                    :block/created-at now
+                    :block/updated-at now
+                    :logseq.property.reaction/emoji-id "+1"
+                    :logseq.property.reaction/target (:db/id block)}]
+      (d/transact! conn [reaction])
+      (is (empty? (:errors (db-validate/validate-local-db! @conn)))))))

deps/outliner/src/logseq/outliner/op.cljs

@@ -1,6 +1,8 @@
 (ns logseq.outliner.op
   "Transact outliner ops"
   (:require [datascript.core :as d]
+            [datascript.impl.entity :as de]
+            [logseq.common.util :as common-util]
             [logseq.db :as ldb]
             [logseq.db.sqlite.export :as sqlite-export]
             [logseq.outliner.core :as outliner-core]
@@ -119,7 +121,12 @@
    [:delete-page
     [:catn
      [:op :keyword]
-     [:args [:tuple ::uuid]]]]])
+     [:args [:tuple ::uuid]]]]
+
+   [:toggle-reaction
+    [:catn
+     [:op :keyword]
+     [:args [:tuple ::uuid ::emoji-id ::maybe-uuid]]]]])
 
 (def ^:private ops-schema
   [:schema {:registry {::id int?
@@ -129,7 +136,9 @@
                        ::block-id :any
                        ::block-ids [:sequential ::block-id]
                        ::class-id int?
+                       ::emoji-id string?
                        ::property-id [:or int? keyword? nil?]
+                       ::maybe-uuid [:maybe :uuid]
                        ::value :any
                        ::values [:sequential ::value]
                        ::option [:maybe map?]
@@ -146,6 +155,37 @@
 
 (defonce ^:private *op-handlers (atom {}))
 
+(defn- reaction-user-id
+  [reaction]
+  (:db/id (:logseq.property/created-by-ref reaction)))
+
+(defn- toggle-reaction!
+  [conn target-uuid emoji-id user-uuid]
+  (when-let [target (d/entity @conn [:block/uuid target-uuid])]
+    (let [user-id (when user-uuid
+                    (:db/id (d/entity @conn [:block/uuid user-uuid])))
+          reactions (:logseq.property.reaction/_target target)
+          match? (fn [reaction]
+                   (and (= emoji-id (:logseq.property.reaction/emoji-id reaction))
+                        (if user-id
+                          (= user-id (reaction-user-id reaction))
+                          (nil? (reaction-user-id reaction)))))
+          existing (some (fn [reaction] (when (match? reaction) reaction)) reactions)]
+      (if existing
+        (do
+          (ldb/transact! conn [[:db/retractEntity (:db/id existing)]]
+                         {:outliner-op :toggle-reaction})
+          true)
+        (let [now (common-util/time-ms)
+              reaction-tx (cond-> {:block/created-at now
+                                   :logseq.property.reaction/emoji-id emoji-id
+                                   :logseq.property.reaction/target (:db/id target)}
+                            user-id
+                            (assoc :logseq.property/created-by-ref user-id))]
+          (ldb/transact! conn [reaction-tx]
+                         {:outliner-op :toggle-reaction})
+          true)))))
+
 (defn register-op-handlers!
   [handlers]
   (reset! *op-handlers handlers))
@@ -258,6 +298,9 @@
          :transact
          (apply ldb/transact! conn args)
 
+         :toggle-reaction
+         (reset! *result (apply toggle-reaction! conn args))
+
          (when-let [handler (get @*op-handlers op)]
            (reset! *result (handler conn args))))))
 

deps/outliner/test/logseq/outliner/op_test.cljs

@@ -0,0 +1,39 @@
+(ns logseq.outliner.op-test
+  (:require [cljs.test :refer [deftest is testing]]
+            [datascript.core :as d]
+            [logseq.db :as ldb]
+            [logseq.db.test.helper :as db-test]
+            [logseq.outliner.op :as outliner-op]))
+
+(deftest toggle-reaction-op
+  (testing "toggles reactions via outliner ops"
+    (let [user-uuid (random-uuid)
+          conn (db-test/create-conn-with-blocks
+                [{:page {:block/title "Test"}
+                  :blocks [{:block/title "Block"}]}])
+          now 1234]
+      (ldb/transact! conn
+                     [{:block/uuid user-uuid
+                       :block/name "user"
+                       :block/title "user"
+                       :block/created-at now
+                       :block/updated-at now
+                       :block/tags #{:logseq.class/Page}}]
+                     {})
+      (let [block (db-test/find-block-by-content @conn "Block")
+            target-uuid (:block/uuid block)]
+        (outliner-op/apply-ops! conn
+                                [[:toggle-reaction [target-uuid "+1" user-uuid]]]
+                                {})
+        (let [block-entity (d/entity @conn [:block/uuid target-uuid])
+              reactions (:logseq.property.reaction/_target block-entity)
+              reaction (first reactions)]
+          (is (= 1 (count reactions)))
+          (is (= "+1" (:logseq.property.reaction/emoji-id reaction)))
+          (is (= (:db/id (d/entity @conn [:block/uuid user-uuid]))
+                 (:db/id (:logseq.property/created-by-ref reaction)))))
+        (outliner-op/apply-ops! conn
+                                [[:toggle-reaction [target-uuid "+1" user-uuid]]]
+                                {})
+        (let [block-entity (d/entity @conn [:block/uuid target-uuid])]
+          (is (empty? (:logseq.property.reaction/_target block-entity))))))))

docs/agent-guide/002-reactions.md

@@ -0,0 +1,76 @@
+# ADR: Reactions via Properties
+
+## Status
+- Proposed
+
+## Context
+- Users want lightweight reactions (e.g., 👍 ❤️) on blocks and pages.
+- Reactions must be stored in the graph so they sync, can be queried, and work across devices.
+- The system already uses properties to attach structured metadata to blocks/pages.
+- We need to show who reacted and which emoji they used.
+
+## Decision
+- Store reactions as separate entities linked to the reacted block/page.
+- Each reaction entity records:
+  - Emoji id (from Logseq’s supported `emojis-data` set).
+  - Optional `:logseq.property/created-by-ref` pointing to the reacting user (absent for anonymous graphs).
+  - Reacted block/page reference.
+  - `:block/created-at` timestamp for the reaction entity.
+- No `:logseq.property/reactions` collection property is required; use the reverse ref
+  `(:logseq.property.reaction/_target node-entity)` to fetch reactions for a node.
+- Keep the property name namespaced in logseq.db.frontend.property/built-in-properties.
+
+### Proposed entity shape
+```
+{:db/id                         ...
+ :logseq.property.reaction/emoji-id             "smile"
+ :logseq.property/created-by-ref                <user-db-id>   ;; omitted for anonymous graphs
+ :logseq.property.reaction/target               <target-db-id> ;; block/page db id
+ :block/created-at              1710000000000}
+```
+
+### Read/write rules
+- Toggling a reaction adds/removes a reaction entity for the current emoji/user.
+- If anonymous, only one reaction per emoji per block/page (no user id).
+- Reactions are derived via reverse reference lookup; no dedicated collection
+  property is stored on the node.
+
+### Example queries
+```clj
+;; Given a block/page entity `node-entity`, fetch all reactions.
+(:logseq.property.reaction/_target node-entity)
+
+;; Filter reactions by emoji id.
+(filter #(= "smile" (:logseq.property.reaction/emoji-id %))
+        (:logseq.property.reaction/_target node-entity))
+
+;; Count reactions per emoji id.
+(->> (:logseq.property.reaction/_target node-entity)
+     (map :logseq.property.reaction/emoji-id)
+     (frequencies))
+
+;; Filter reactions by user id (when present).
+(filter #(= user-db-id (:logseq.property/created-by-ref %))
+        (:logseq.property.reaction/_target node-entity))
+```
+
+## Consequences
+- Reactions sync naturally as part of DB transactions and are queryable.
+- Data model supports “who reacted” and multiple users per emoji without map merging.
+- Adds more entities; need efficient queries and indexes.
+
+## Alternatives Considered
+- **Dedicated table/attribute per emoji**: complicates schema, increases complexity.
+- **Property map (emoji -> users)**: smaller but harder to resolve conflicts and query per user.
+- **Inline text markers**: not structured, hard to query and sync.
+
+## Open Questions
+- Which user identifier should be stored as `:logseq.property/created-by-ref`?
+  Each user has a page in the graph
+- How to handle anonymous/local graphs (no user identity)?
+  Record reactions, for anonymous graphs, don't store :logseq.property/created-by-ref
+
+## Notes for Implementation
+- Add emoji entity schema to DB validation.
+- UI should show a summary (emoji + count) and a hover/popover with user list.
+- User can toggle reaction.