Sending emoji reactions

Author: dahlia

.vscode/settings.json

@@ -47,6 +47,7 @@
     "activitypub",
     "botkit",
     "denokv",
+    "fanout",
     "fedi",
     "Fedify",
     "fediverse",
@@ -72,6 +73,7 @@
     "unfollowing",
     "unfollows",
     "unliked",
+    "unreact",
     "uuidv7",
     "vitepress"
   ]

CHANGES.md

@@ -21,9 +21,13 @@ To be released.
      -  Added `CustomEmoji` type.
      -  Added `DeferredCustomEmoji` type.
 
- -  Added `Emoji` type.
+ -  Added emoji reaction support.
 
- -  Added `isEmoji()` predicate function.
+     -  Added `Emoji` type.
+     -  Added `isEmoji()` predicate function.
+     -  Added `Message.react()` method.
+     -  Added `Reaction` interface.
+     -  Added `AuthorizedReaction` interface.
 
  -  Added `SessionGetOutboxOptions` interface.
 

src/message-impl.test.ts

@@ -20,7 +20,10 @@ import {
   ChatMessage,
   Create,
   Delete,
+  Emoji as CustomEmoji,
+  EmojiReact,
   Hashtag,
+  Image,
   Like as RawLike,
   Mention,
   Note,
@@ -36,6 +39,7 @@ 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 { type DeferredCustomEmoji, isEmoji } from "./emoji.ts";
 import {
   createMessage,
   getMessageClass,
@@ -578,3 +582,141 @@ Deno.test("getMessageVisibility()", () => {
   );
   assertEquals(getMessageVisibility([], [], new Person({})), "unknown");
 });
+
+Deno.test("MessageImpl.react()", 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/react-test-note",
+    ),
+    content: "<p>React to this!</p>",
+    attribution: new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    }),
+    to: PUBLIC_COLLECTION,
+  });
+  const message = await createMessage<Note, void>(
+    originalPost,
+    session,
+    {},
+  );
+
+  await t.step("react() with string emoji", async () => {
+    ctx.sentActivities = []; // Clear previous activities
+    const emoji = "👍";
+    assert(isEmoji(emoji));
+    const reaction = await message.react(emoji);
+    assertEquals(ctx.sentActivities.length, 2);
+    const { recipients, activity } = ctx.sentActivities[0];
+    assertEquals(recipients, "followers");
+    assertInstanceOf(activity, EmojiReact);
+    assertEquals(activity.actorId, ctx.getActorUri(bot.identifier));
+    assertEquals(activity.objectId, message.id);
+    assertEquals(activity.name, "👍");
+    assertEquals(await Array.fromAsync(activity.getTags()), []);
+    const { recipients: recipients2, activity: activity2 } =
+      ctx.sentActivities[1];
+    assertEquals(recipients2, [message.actor]);
+    assertInstanceOf(activity2, EmojiReact);
+    assertEquals(activity2, activity);
+    assertEquals(reaction.actor, await session.getActor());
+    assertEquals(reaction.raw, activity);
+    assertEquals(reaction.id, activity.id);
+    assertEquals(reaction.message, message);
+    assertEquals(reaction.emoji, emoji);
+
+    // Test unreact
+    ctx.sentActivities = [];
+    await reaction.unreact();
+    assertEquals(ctx.sentActivities.length, 2);
+    const { recipients: urRecipients, activity: urActivity } =
+      ctx.sentActivities[0];
+    assertEquals(urRecipients, "followers");
+    assertInstanceOf(urActivity, Undo);
+    assertEquals(urActivity.actorId, ctx.getActorUri(bot.identifier));
+    const urObject = await urActivity.getObject();
+    assertInstanceOf(urObject, EmojiReact);
+    assertEquals(urObject.id, reaction.id);
+    const { recipients: urRecipients2, activity: urActivity2 } =
+      ctx.sentActivities[1];
+    assertEquals(urRecipients2, [message.actor]);
+    assertInstanceOf(urActivity2, Undo);
+    assertEquals(urActivity2, urActivity);
+  });
+
+  await t.step("react() with CustomEmoji", async () => {
+    ctx.sentActivities = [];
+    const customEmoji = new CustomEmoji({
+      id: new URL("https://example.com/emojis/custom"),
+      name: ":custom:",
+      icon: new Image({
+        url: new URL("https://example.com/emojis/custom.png"),
+      }),
+    });
+    const reaction = await message.react(customEmoji);
+    assertEquals(ctx.sentActivities.length, 2);
+    const { activity } = ctx.sentActivities[0];
+    assertInstanceOf(activity, EmojiReact);
+    assertEquals(activity.name, ":custom:");
+    const tags = await Array.fromAsync(activity.getTags());
+    assertEquals(tags.length, 1);
+    assertEquals(tags[0], customEmoji);
+    assertEquals(reaction.emoji, customEmoji);
+
+    // Test unreact
+    ctx.sentActivities = [];
+    await reaction.unreact();
+    assertEquals(ctx.sentActivities.length, 2);
+    const { activity: urActivity } = ctx.sentActivities[0];
+    assertInstanceOf(urActivity, Undo);
+    const urObject = await urActivity.getObject();
+    assertInstanceOf(urObject, EmojiReact);
+    assertEquals(urObject.id, reaction.id);
+    const urTags = await Array.fromAsync(urActivity.getTags());
+    assertEquals(urTags.length, 1);
+    assertEquals(urTags[0], customEmoji);
+  });
+
+  await t.step("react() with DeferredCustomEmoji", async () => {
+    ctx.sentActivities = [];
+    const deferredEmoji: DeferredCustomEmoji<void> = (sessionParam) => {
+      assertEquals(sessionParam, session); // Ensure correct session is passed
+      return new CustomEmoji({
+        id: new URL("https://example.com/emojis/deferred"),
+        name: ":deferred:",
+        icon: new Image({
+          url: new URL("https://example.com/emojis/deferred.png"),
+        }),
+      });
+    };
+    const reaction = await message.react(deferredEmoji);
+    assertEquals(ctx.sentActivities.length, 2);
+    const { activity } = ctx.sentActivities[0];
+    assertInstanceOf(activity, EmojiReact);
+    assertEquals(activity.name, ":deferred:");
+    const tags = await Array.fromAsync(activity.getTags());
+    assertEquals(tags.length, 1);
+    assertInstanceOf(tags[0], CustomEmoji);
+    assertEquals(tags[0].id?.href, "https://example.com/emojis/deferred");
+    assertEquals(reaction.emoji, tags[0]);
+
+    // Test unreact
+    ctx.sentActivities = [];
+    await reaction.unreact();
+    assertEquals(ctx.sentActivities.length, 2);
+    const { activity: urActivity } = ctx.sentActivities[0];
+    assertInstanceOf(urActivity, Undo);
+    const urObject = await urActivity.getObject();
+    assertInstanceOf(urObject, EmojiReact);
+    assertEquals(urObject.id, reaction.id);
+    const urTags = await Array.fromAsync(urActivity.getTags());
+    assertEquals(urTags.length, 1);
+    assertEquals(urTags[0], tags[0]); // Should be the resolved CustomEmoji
+  });
+});

src/message-impl.ts

@@ -22,6 +22,8 @@ import {
   Create,
   Delete,
   Document,
+  Emoji as CustomEmoji,
+  EmojiReact,
   Hashtag,
   isActor,
   Like as RawLike,
@@ -39,6 +41,7 @@ import type { LanguageTag } from "@phensley/language-tag";
 import { unescape } from "@std/html/entities";
 import { generate as uuidv7 } from "@std/uuid/unstable-v7";
 import { FilterXSS, getDefaultWhiteList } from "xss";
+import { DeferredCustomEmoji, Emoji } from "./emoji.ts";
 import type {
   AuthorizedMessage,
   AuthorizedSharedMessage,
@@ -47,7 +50,7 @@ import type {
   MessageShareOptions,
   MessageVisibility,
 } from "./message.ts";
-import type { AuthorizedLike } from "./reaction.ts";
+import type { AuthorizedLike, AuthorizedReaction } from "./reaction.ts";
 import type { Uuid } from "./repository.ts";
 import type { SessionImpl } from "./session-impl.ts";
 import type {
@@ -97,7 +100,7 @@ export class MessageImpl<T extends MessageClass, TContextData>
     session: SessionImpl<TContextData>,
     message: Omit<
       Message<T, TContextData>,
-      "delete" | "reply" | "share" | "like"
+      "delete" | "reply" | "share" | "like" | "react"
     >,
   ) {
     this.session = session;
@@ -234,6 +237,7 @@ export class MessageImpl<T extends MessageClass, TContextData>
       {
         preferSharedInbox: true,
         excludeBaseUris: [new URL(this.session.context.origin)],
+        fanout: "skip",
       },
     );
     return {
@@ -263,6 +267,79 @@ export class MessageImpl<T extends MessageClass, TContextData>
           {
             preferSharedInbox: true,
             excludeBaseUris: [new URL(this.session.context.origin)],
+            fanout: "skip",
+          },
+        );
+      },
+    };
+  }
+
+  async react(
+    emoji: Emoji | CustomEmoji | DeferredCustomEmoji<TContextData>,
+  ): Promise<AuthorizedReaction<TContextData>> {
+    const uuid = crypto.randomUUID();
+    const actor = this.session.context.getActorUri(this.session.bot.identifier);
+    const id = new URL(`#react/${uuid}`, actor);
+    if (typeof emoji === "function") {
+      emoji = await emoji(this.session);
+    }
+    const activity = new EmojiReact({
+      id,
+      actor,
+      object: this.id,
+      name: typeof emoji === "string" ? emoji : emoji.name,
+      tags: typeof emoji === "string" ? [] : [emoji],
+    });
+    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)],
+        fanout: "skip",
+      },
+    );
+    return {
+      raw: activity,
+      id,
+      actor: await this.session.getActor(),
+      message: this,
+      emoji,
+      unreact: async () => {
+        const undo = new Undo({
+          id: new URL(`#unreact/${uuid}`, actor),
+          actor,
+          object: activity,
+          name: typeof emoji === "string" ? emoji : emoji.name,
+          tags: typeof emoji === "string" ? [] : [emoji],
+        });
+        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)],
+            fanout: "skip",
           },
         );
       },

src/message.ts

@@ -19,12 +19,14 @@ import type {
   Article,
   ChatMessage,
   Document,
+  Emoji as CustomEmoji,
   Hashtag,
   Note,
   Question,
 } from "@fedify/fedify/vocab";
 import type { LanguageTag } from "@phensley/language-tag";
-import type { AuthorizedLike } from "./reaction.ts";
+import { DeferredCustomEmoji, Emoji } from "./emoji.ts";
+import type { AuthorizedLike, AuthorizedReaction } from "./reaction.ts";
 import type {
   SessionPublishOptions,
   SessionPublishOptionsWithClass,
@@ -196,6 +198,17 @@ export interface Message<T extends MessageClass, TContextData> {
    * @returns The like object.
    */
   like(): Promise<AuthorizedLike<TContextData>>;
+
+  /**
+   * Reacts to the message with a Unicode emoji or a custom emoji.
+   * @param emoji The emoji to react with.  It can be either a Unicode emoji or
+   *              a custom emoji.
+   * @returns The reaction object.
+   * @since 0.2.0
+   */
+  react(
+    emoji: Emoji | CustomEmoji | DeferredCustomEmoji<TContextData>,
+  ): Promise<AuthorizedReaction<TContextData>>;
 }
 
 /**

src/mod.ts

@@ -63,7 +63,14 @@ export type {
   MessageVisibility,
   SharedMessage,
 } from "./message.ts";
-export { type AuthorizedLike, type Like, RawLike } from "./reaction.ts";
+export {
+  type AuthorizedLike,
+  type AuthorizedReaction,
+  EmojiReact,
+  type Like,
+  RawLike,
+  type Reaction,
+} from "./reaction.ts";
 export {
   Announce,
   Create,