Bot.onLike event

Author: dahlia

docs/concepts/events.md

@@ -274,3 +274,24 @@ bot.onSharedMessage = async (session, sharedMessage) => {
 > [!TIP]
 > The `~Bot.onSharedMessage` event handler can be called when someone your
 > bot does not follow shares a message on your bot.
+
+
+Like
+----
+
+The `~Bot.onLike` event handler is called when someone likes messages on your
+bot or actors your bot follows.  It receives a `Like` object, which represents
+the like activity, as the second argument.
+
+The following is an example of a like event handler that sends a direct message
+when someone likes a message on your bot:
+
+~~~~ typescript
+bot.onLike = async (session, like) => {
+  if (like.message.actor.id?.href !== session.actorId.href) return;
+  await session.publish(
+    text`Thanks for liking my message, ${like.actor}!`,
+    { visibility: "direct" },
+  );
+};
+~~~~

src/bot-impl.test.ts

@@ -24,6 +24,7 @@ import {
   CryptographicKey,
   Follow,
   Image,
+  Like as RawLike,
   Mention,
   Note,
   Person,
@@ -43,6 +44,7 @@ import { BotImpl } from "./bot-impl.ts";
 import { parseSemVer } from "./bot.ts";
 import type { FollowRequest } from "./follow.ts";
 import type { Message, MessageClass, SharedMessage } from "./message.ts";
+import type { Like } from "./reaction.ts";
 import { MemoryRepository } from "./repository.ts";
 import { SessionImpl } from "./session-impl.ts";
 import type { Session } from "./session.ts";
@@ -1821,6 +1823,38 @@ Deno.test("BotImpl.onAnnounced()", async () => {
   assertEquals(ctx.forwardedRecipients, []);
 });
 
+Deno.test("BotImpl.onLiked()", async () => {
+  const bot = new BotImpl<void>({
+    kv: new MemoryKvStore(),
+    username: "bot",
+  });
+  const likes: [Session<void>, Like<void>][] = [];
+  bot.onLike = (session, like) => void (likes.push([session, like]));
+  const ctx = createMockInboxContext(bot, "https://example.com", "bot");
+  const rawLike = new RawLike({
+    id: new URL("https://example.com/ap/actor/bot/announce/1"),
+    actor: new URL("https://example.com/ap/actor/bot"),
+    object: new Note({
+      id: new URL("https://example.com/ap/actor/bot/note/1"),
+      attribution: new URL("https://example.com/ap/actor/bot"),
+      to: PUBLIC_COLLECTION,
+      cc: new URL("https://example.com/ap/actor/bot/followers"),
+      content: "Hello, world!",
+    }),
+  });
+  await bot.onLiked(ctx, rawLike);
+  assertEquals(likes.length, 1);
+  const [session, like] = likes[0];
+  assertEquals(session.bot, bot);
+  assertEquals(session.context, ctx);
+  assertEquals(like.raw, rawLike);
+  assertEquals(like.id, rawLike.id);
+  assertEquals(like.actor.id, rawLike.actorId);
+  assertEquals(like.message.id, rawLike.objectId);
+  assertEquals(ctx.sentActivities, []);
+  assertEquals(ctx.forwardedRecipients, []);
+});
+
 Deno.test("BotImpl.dispatchNodeInfo()", () => {
   const bot = new BotImpl<void>({
     kv: new MemoryKvStore(),

src/bot-impl.ts

@@ -31,6 +31,7 @@ import {
   Image,
   type InboxContext,
   isActor,
+  Like as RawLike,
   type Link,
   Mention,
   type NodeInfo,
@@ -56,6 +57,7 @@ import type { Bot, CreateBotOptions, PagesOptions } from "./bot.ts";
 import type {
   AcceptEventHandler,
   FollowEventHandler,
+  LikeEventHandler,
   MentionEventHandler,
   MessageEventHandler,
   RejectEventHandler,
@@ -67,10 +69,12 @@ import { FollowRequestImpl } from "./follow-impl.ts";
 import {
   createMessage,
   getMessageVisibility,
+  isMessageObject,
   messageClasses,
 } from "./message-impl.ts";
 import type { Message, MessageClass, SharedMessage } from "./message.ts";
 import { app } from "./pages.tsx";
+import type { Like } from "./reaction.ts";
 import { KvRepository, type Repository, type Uuid } from "./repository.ts";
 import { SessionImpl } from "./session-impl.ts";
 import type { Session } from "./session.ts";
@@ -108,6 +112,7 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
   onReply?: ReplyEventHandler<TContextData>;
   onMessage?: MessageEventHandler<TContextData>;
   onSharedMessage?: SharedMessageEventHandler<TContextData>;
+  onLike?: LikeEventHandler<TContextData>;
 
   constructor(options: BotImplOptions<TContextData>) {
     this.identifier = options.identifier ?? "bot";
@@ -207,6 +212,7 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
       .on(Reject, this.onFollowRejected.bind(this))
       .on(Create, this.onCreated.bind(this))
       .on(Announce, this.onAnnounced.bind(this))
+      .on(RawLike, this.onLiked.bind(this))
       .setSharedKeyDispatcher(this.dispatchSharedKey.bind(this));
     if (this.software != null) {
       this.federation.setNodeInfoDispatcher(
@@ -654,12 +660,7 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     } else {
       object = await announce.getObject(ctx);
     }
-    if (
-      !(object instanceof Article || object instanceof ChatMessage ||
-        object instanceof Note || object instanceof Question)
-    ) {
-      return;
-    }
+    if (!isMessageObject(object)) return;
     const session = this.getSession(ctx);
     const actor = announce.actorId.href == session.actorId.href
       ? await session.getActor()
@@ -676,6 +677,38 @@ export class BotImpl<TContextData> implements Bot<TContextData> {
     await this.onSharedMessage(session, sharedMessage);
   }
 
+  async onLiked(ctx: InboxContext<TContextData>, like: RawLike): Promise<void> {
+    if (this.onLike == null || like.id == null || like.actorId == null) return;
+    const objectUri = ctx.parseUri(like.objectId);
+    let object: Object | null = null;
+    if (
+      objectUri?.type === "object" &&
+      // deno-lint-ignore no-explicit-any
+      messageClasses.includes(objectUri.class as any)
+    ) {
+      const msg = await this.repository.getMessage(objectUri.values.id as Uuid);
+      if (msg instanceof Create) object = await msg.getObject(ctx);
+    } else {
+      object = await like.getObject(ctx);
+    }
+    if (!isMessageObject(object)) return;
+    const session = this.getSession(ctx);
+    const actor = like.actorId.href == session.actorId.href
+      ? await session.getActor()
+      : await like.getActor(ctx);
+    if (actor == null) return;
+    const message = await createMessage(object, session, {});
+    await this.onLike(
+      session,
+      {
+        raw: like,
+        id: like.id,
+        actor,
+        message,
+      } satisfies Like<TContextData>,
+    );
+  }
+
   dispatchNodeInfo(_ctx: Context<TContextData>): NodeInfo {
     return {
       software: this.software!,

src/bot.test.ts

@@ -16,14 +16,17 @@
 import { MemoryKvStore } from "@fedify/fedify/federation";
 import type { Actor } from "@fedify/fedify/vocab";
 import { assertEquals } from "@std/assert/equals";
+import type { BotImpl } from "./bot-impl.ts";
 import { createBot } from "./bot.ts";
 import type { FollowRequest } from "./follow.ts";
-import type { Message, MessageClass } from "./message.ts";
+import type { Message, MessageClass, SharedMessage } from "./message.ts";
+import type { Like } from "./reaction.ts";
 import type { Session } from "./session.ts";
 
 Deno.test("createBot()", async () => {
   const kv = new MemoryKvStore();
-  const bot = createBot({ kv, identifier: "bot-id", username: "bot" });
+  const bot = createBot<void>({ kv, identifier: "bot-id", username: "bot" });
+  const { impl } = bot as unknown as { impl: BotImpl<void> };
   const _federation = bot.federation;
   assertEquals(bot.identifier, "bot-id");
   const session = bot.getSession("https://example.com");
@@ -32,24 +35,59 @@ Deno.test("createBot()", async () => {
   function onFollow(_session: Session<void>, _followRequest: FollowRequest) {}
   bot.onFollow = onFollow;
   assertEquals(bot.onFollow, onFollow);
+  assertEquals(impl.onFollow, onFollow);
 
   function onUnfollow(_session: Session<void>, _follower: Actor) {}
   bot.onUnfollow = onUnfollow;
   assertEquals(bot.onUnfollow, onUnfollow);
+  assertEquals(impl.onUnfollow, onUnfollow);
+
+  function onAcceptFollow(_session: Session<void>, _accepter: Actor) {}
+  bot.onAcceptFollow = onAcceptFollow;
+  assertEquals(bot.onAcceptFollow, onAcceptFollow);
+  assertEquals(impl.onAcceptFollow, onAcceptFollow);
+
+  function onRejectFollow(_session: Session<void>, _rejecter: Actor) {}
+  bot.onRejectFollow = onRejectFollow;
+  assertEquals(bot.onRejectFollow, onRejectFollow);
+  assertEquals(impl.onRejectFollow, onRejectFollow);
 
   function onMention(
     _session: Session<void>,
     _message: Message<MessageClass, void>,
   ) {}
   bot.onMention = onMention;
   assertEquals(bot.onMention, onMention);
+  assertEquals(impl.onMention, onMention);
 
   function onReply(
     _session: Session<void>,
     _message: Message<MessageClass, void>,
   ) {}
   bot.onReply = onReply;
   assertEquals(bot.onReply, onReply);
+  assertEquals(impl.onReply, onReply);
+
+  function onMessage(
+    _session: Session<void>,
+    _message: Message<MessageClass, void>,
+  ) {}
+  bot.onMessage = onMessage;
+  assertEquals(bot.onMessage, onMessage);
+  assertEquals(impl.onMessage, onMessage);
+
+  function onSharedMessage(
+    _session: Session<void>,
+    _message: SharedMessage<MessageClass, void>,
+  ) {}
+  bot.onSharedMessage = onSharedMessage;
+  assertEquals(bot.onSharedMessage, onSharedMessage);
+  assertEquals(impl.onSharedMessage, onSharedMessage);
+
+  function onLike(_session: Session<void>, _like: Like<void>) {}
+  bot.onLike = onLike;
+  assertEquals(bot.onLike, onLike);
+  assertEquals(impl.onLike, onLike);
 
   const response = await bot.fetch(
     new Request(

src/bot.ts

@@ -25,6 +25,7 @@ import { BotImpl } from "./bot-impl.ts";
 import type {
   AcceptEventHandler,
   FollowEventHandler,
+  LikeEventHandler,
   MentionEventHandler,
   MessageEventHandler,
   RejectEventHandler,
@@ -127,6 +128,11 @@ export interface Bot<TContextData> {
    * your bot needs to follow others first.
    */
   onSharedMessage?: SharedMessageEventHandler<TContextData>;
+
+  /**
+   * An event handler for a like of a message.
+   */
+  onLike?: LikeEventHandler<TContextData>;
 }
 
 /**
@@ -327,6 +333,7 @@ export function createBot<TContextData = void>(
   // we wrap a BotImpl instance with a plain object.
   // See also https://github.com/denoland/deno/issues/24062
   const wrapper = {
+    impl: bot,
     get federation() {
       return bot.federation;
     },
@@ -352,6 +359,18 @@ export function createBot<TContextData = void>(
     set onUnfollow(value) {
       bot.onUnfollow = value;
     },
+    get onAcceptFollow() {
+      return bot.onAcceptFollow;
+    },
+    set onAcceptFollow(value) {
+      bot.onAcceptFollow = value;
+    },
+    get onRejectFollow() {
+      return bot.onRejectFollow;
+    },
+    set onRejectFollow(value) {
+      bot.onRejectFollow = value;
+    },
     get onMention() {
       return bot.onMention;
     },
@@ -364,7 +383,25 @@ export function createBot<TContextData = void>(
     set onReply(value) {
       bot.onReply = value;
     },
-  } satisfies Bot<TContextData>;
+    get onMessage() {
+      return bot.onMessage;
+    },
+    set onMessage(value) {
+      bot.onMessage = value;
+    },
+    get onSharedMessage() {
+      return bot.onSharedMessage;
+    },
+    set onSharedMessage(value) {
+      bot.onSharedMessage = value;
+    },
+    get onLike() {
+      return bot.onLike;
+    },
+    set onLike(value) {
+      bot.onLike = value;
+    },
+  } satisfies Bot<TContextData> & { impl: BotImpl<TContextData> };
   // @ts-ignore: the wrapper implements BotWithVoidContextData
   return wrapper;
 }

src/events.ts

@@ -16,6 +16,7 @@
 import type { Actor } from "@fedify/fedify/vocab";
 import type { FollowRequest } from "./follow.ts";
 import type { Message, MessageClass, SharedMessage } from "./message.ts";
+import type { Like } from "./reaction.ts";
 import type { Session } from "./session.ts";
 
 /**
@@ -107,3 +108,14 @@ export type SharedMessageEventHandler<TContextData> = (
   session: Session<TContextData>,
   message: SharedMessage<MessageClass, TContextData>,
 ) => void | Promise<void>;
+
+/**
+ * An event handler for a like of a message.
+ * @typeParam TContextData The type of the context data.
+ * @param session The session of the bot.
+ * @param like The like activity of the message.
+ */
+export type LikeEventHandler<TContextData> = (
+  session: Session<TContextData>,
+  like: Like<TContextData>,
+) => void | Promise<void>;