Message.like() & Like.unlike() methods

Author: dahlia

deno.json

@@ -12,6 +12,7 @@
     "./events": "./src/events.ts",
     "./follow": "./src/follow.ts",
     "./message": "./src/message.ts",
+    "./reaction": "./src/reaction.ts",
     "./session": "./src/session.ts",
     "./text": "./src/text.ts"
   },

docs/concepts/message.md

@@ -8,9 +8,10 @@ Message
 =======
 
 The `Message` object is a representation of a message that is published to
-the fediverse.  You can interact with the `Message` object such as [replying
-to it](#replying-to-a-message), [sharing it](#sharing-a-message), [deleting
-it](#deleting-a-message), and so on.
+the fediverse.  You can interact with the `Message` object such as
+[liking it](#liking-a-message), [replying to it](#replying-to-a-message),
+[sharing it](#sharing-a-message), [deleting it](#deleting-a-message),
+and so on.
 
 
 Where to get a `Message` object
@@ -506,6 +507,34 @@ setTimeout(async () => {
 > object.
 
 
+Liking a message
+----------------
+
+You can like a message by calling the `~Message.like()` method:
+
+~~~~ typescript
+const message = await session.publish(
+  text`This message will be liked.`
+);
+await message.like();  // [!code highlight]
+~~~~
+
+> [!CAUTION]
+> You may call the `~Message.like()` method on a message that is already liked,
+> but it will not raise an error.  Under the hood, such a call actually sends
+> multiple `Like` activities to the fediverse, whose behavior is
+> undefined—some servers may ignore the duplicated activities, some servers
+> may allow them and count them as multiple likes.
+
+If you need to undo the liking, you can call the `~AuthorizedLike.unlike()`
+method:
+
+~~~~ typescript
+const like = await message.like();
+await like.unlike();  // [!code highlight]
+~~~~
+
+
 Replying to a message
 ---------------------
 

docs/recipes.md

@@ -108,6 +108,20 @@ Deno.cron("scheduled messages", "0 0 12 * * *", async () => {
 [`Deno.cron()`]: https://docs.deno.com/api/deno/~/Deno.cron
 
 
+Automatically liking mentions
+-----------------------------
+
+It is simple to automatically like mentions of your bot.  You can use the
+[`onMention`](./concepts/events.md#mention) event handler and
+the [`Message.like()`](./concepts/message.md#liking-a-message) method together:
+
+~~~~ typescript
+bot.onMention = async (session, message) => {
+  await message.like();
+};
+~~~~
+
+
 Automatically replying to mentions
 ----------------------------------
 

src/message-impl.test.ts

@@ -16,13 +16,17 @@
 import { MemoryKvStore } from "@fedify/fedify/federation";
 import {
   Announce,
+  Article,
+  ChatMessage,
   Create,
   Delete,
   Hashtag,
+  Like as RawLike,
   Mention,
   Note,
   Person,
   PUBLIC_COLLECTION,
+  Question,
   Tombstone,
   Undo,
   Update,
@@ -32,12 +36,44 @@ import { assertEquals } from "@std/assert/equals";
 import { assertInstanceOf } from "@std/assert/instance-of";
 import { assertRejects } from "@std/assert/rejects";
 import { BotImpl } from "./bot-impl.ts";
-import { createMessage, getMessageVisibility } from "./message-impl.ts";
+import {
+  createMessage,
+  getMessageClass,
+  getMessageVisibility,
+  isMessageObject,
+} from "./message-impl.ts";
 import { MemoryRepository } from "./repository.ts";
 import { createMockContext } from "./session-impl.test.ts";
 import { SessionImpl } from "./session-impl.ts";
 import { text } from "./text.ts";
 
+Deno.test("isMessageObject()", () => {
+  assert(isMessageObject(new Article({})));
+  assert(isMessageObject(new ChatMessage({})));
+  assert(isMessageObject(new Note({})));
+  assert(isMessageObject(new Question({})));
+  assert(!isMessageObject(new Person({})));
+});
+
+Deno.test("getMessageClass()", () => {
+  assertEquals(
+    getMessageClass(new Article({})),
+    Article,
+  );
+  assertEquals(
+    getMessageClass(new ChatMessage({})),
+    ChatMessage,
+  );
+  assertEquals(
+    getMessageClass(new Note({})),
+    Note,
+  );
+  assertEquals(
+    getMessageClass(new Question({})),
+    Question,
+  );
+});
+
 Deno.test("createMessage()", async () => {
   const bot = new BotImpl<void>({ kv: new MemoryKvStore(), username: "bot" });
   const session = bot.getSession("https://example.com", undefined);
@@ -319,6 +355,71 @@ Deno.test("MessageImpl.share()", async (t) => {
   });
 });
 
+Deno.test("MessageImpl.like()", async (t) => {
+  const bot = new BotImpl<void>({
+    kv: new MemoryKvStore(),
+    username: "bot",
+  });
+  const ctx = createMockContext(bot, "https://example.com");
+  const session = new SessionImpl(bot, ctx);
+  const originalPost = new Note({
+    id: new URL(
+      "https://example.com/ap/note/c1c792ce-a0be-4685-b396-e59e5ef8c788",
+    ),
+    content: "<p>Hello, world!</p>",
+    attribution: new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    }),
+    to: new URL("https://example.com/ap/actor/john/followers"),
+    cc: PUBLIC_COLLECTION,
+  });
+  const message = await createMessage<Note, void>(
+    originalPost,
+    session,
+    {},
+  );
+  const like = await message.like();
+
+  await t.step("like()", async () => {
+    assertEquals(ctx.sentActivities.length, 2);
+    const { recipients, activity } = ctx.sentActivities[0];
+    assertEquals(recipients, "followers");
+    assertInstanceOf(activity, RawLike);
+    assertEquals(activity.actorId, ctx.getActorUri(bot.identifier));
+    assertEquals(activity.objectId, message.id);
+    const { recipients: recipients2, activity: activity2 } =
+      ctx.sentActivities[1];
+    assertEquals(recipients2, [message.actor]);
+    assertInstanceOf(activity2, RawLike);
+    assertEquals(activity2, activity);
+    assertEquals(like.actor, await session.getActor());
+    assertEquals(like.raw, activity);
+    assertEquals(like.id, activity.id);
+    assertEquals(like.message, message);
+  });
+
+  ctx.sentActivities = [];
+
+  await t.step("unlike()", async () => {
+    await like.unlike();
+    assertEquals(ctx.sentActivities.length, 2);
+    const { recipients, activity } = ctx.sentActivities[0];
+    assertEquals(recipients, "followers");
+    assertInstanceOf(activity, Undo);
+    assertEquals(activity.actorId, ctx.getActorUri(bot.identifier));
+    const object = await activity.getObject();
+    assertInstanceOf(object, RawLike);
+    assertEquals(object.actorId, ctx.getActorUri(bot.identifier));
+    assertEquals(object.objectId, message.id);
+    const { recipients: recipients2, activity: activity2 } =
+      ctx.sentActivities[1];
+    assertEquals(recipients2, [message.actor]);
+    assertInstanceOf(activity2, Undo);
+    assertEquals(activity2, activity);
+  });
+});
+
 Deno.test("AuthorizedMessage.update()", async (t) => {
   const actorA = new Person({
     id: new URL("https://example.com/ap/actor/john"),

src/message-impl.ts

@@ -24,6 +24,7 @@ import {
   Document,
   Hashtag,
   isActor,
+  Like as RawLike,
   type Link,
   Mention,
   Note,
@@ -46,6 +47,7 @@ import type {
   MessageShareOptions,
   MessageVisibility,
 } from "./message.ts";
+import type { AuthorizedLike } from "./reaction.ts";
 import type { Uuid } from "./repository.ts";
 import type { SessionImpl } from "./session-impl.ts";
 import type {
@@ -93,7 +95,10 @@ export class MessageImpl<T extends MessageClass, TContextData>
 
   constructor(
     session: SessionImpl<TContextData>,
-    message: Omit<Message<T, TContextData>, "delete" | "reply" | "share">,
+    message: Omit<
+      Message<T, TContextData>,
+      "delete" | "reply" | "share" | "like"
+    >,
   ) {
     this.session = session;
     this.raw = message.raw;
@@ -203,6 +208,66 @@ export class MessageImpl<T extends MessageClass, TContextData>
       },
     };
   }
+
+  async like(): Promise<AuthorizedLike<TContextData>> {
+    const uuid = crypto.randomUUID();
+    const actor = this.session.context.getActorUri(this.session.bot.identifier);
+    const id = new URL(`#like/${uuid}`, actor);
+    const activity = new RawLike({
+      id,
+      actor,
+      object: this.id,
+    });
+    await this.session.context.sendActivity(
+      this.session.bot,
+      "followers",
+      activity,
+      {
+        preferSharedInbox: true,
+        excludeBaseUris: [new URL(this.session.context.origin)],
+      },
+    );
+    await this.session.context.sendActivity(
+      this.session.bot,
+      this.actor,
+      activity,
+      {
+        preferSharedInbox: true,
+        excludeBaseUris: [new URL(this.session.context.origin)],
+      },
+    );
+    return {
+      raw: activity,
+      id,
+      actor: await this.session.getActor(),
+      message: this,
+      unlike: async () => {
+        const undo = new Undo({
+          id: new URL(`#unlike/${uuid}`, actor),
+          actor,
+          object: activity,
+        });
+        await this.session.context.sendActivity(
+          this.session.bot,
+          "followers",
+          undo,
+          {
+            preferSharedInbox: true,
+            excludeBaseUris: [new URL(this.session.context.origin)],
+          },
+        );
+        await this.session.context.sendActivity(
+          this.session.bot,
+          this.actor,
+          undo,
+          {
+            preferSharedInbox: true,
+            excludeBaseUris: [new URL(this.session.context.origin)],
+          },
+        );
+      },
+    };
+  }
 }
 
 export class AuthorizedMessageImpl<T extends MessageClass, TContextData>

src/message.ts

@@ -24,6 +24,7 @@ import type {
   Question,
 } from "@fedify/fedify/vocab";
 import type { LanguageTag } from "@phensley/language-tag";
+import type { AuthorizedLike } from "./reaction.ts";
 import type {
   SessionPublishOptions,
   SessionPublishOptionsWithClass,
@@ -189,6 +190,12 @@ export interface Message<T extends MessageClass, TContextData> {
   share(
     options?: MessageShareOptions,
   ): Promise<AuthorizedSharedMessage<T, TContextData>>;
+
+  /**
+   * Likes the message.
+   * @returns The like object.
+   */
+  like(): Promise<AuthorizedLike<TContextData>>;
 }
 
 /**

src/mod.ts

@@ -57,6 +57,7 @@ export type {
   MessageVisibility,
   SharedMessage,
 } from "./message.ts";
+export { type AuthorizedLike, type Like, RawLike } from "./reaction.ts";
 export {
   Announce,
   Create,

src/reaction.ts

@@ -0,0 +1,59 @@
+// BotKit by Fedify: A framework for creating ActivityPub bots
+// Copyright (C) 2025 Hong Minhee <https://hongminhee.org/>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import type { Actor, Like as RawLike } from "@fedify/fedify/vocab";
+import type { Message, MessageClass } from "./message.ts";
+export { type Actor, Like as RawLike } from "@fedify/fedify/vocab";
+
+/**
+ * A like of a message.  It is a thin wrapper around a `Like`, which is
+ * a Fedify object.
+ * @typeParam TContextData The type of the context data.
+ */
+export interface Like<TContextData> {
+  /**
+   * The underlying raw `Like` activity.
+   */
+  readonly raw: RawLike;
+
+  /**
+   * The URI of the like activity.
+   */
+  readonly id: URL;
+
+  /**
+   * The actor who liked the message.
+   */
+  readonly actor: Actor;
+
+  /**
+   * The message that was liked.
+   */
+  readonly message: Message<MessageClass, TContextData>;
+}
+
+/**
+ * An authorized like of a message.  Usually it is a like that the bot
+ * itself made.
+ * @typeParam TContextData The type of the context data.
+ */
+export interface AuthorizedLike<TContextData> extends Like<TContextData> {
+  /**
+   * Undoes the like.
+   *
+   * If the like is already undone, this method does nothing.
+   */
+  unlike(): Promise<void>;
+}