Merge tag '0.7.13'

Hollo 0.7.13

Author: dahlia

CHANGES.md

@@ -156,6 +156,19 @@ To be released.
 [Fedify debugger]: https://fedify.dev/manual/debug
 
 
+Version 0.7.13
+--------------
+
+Released on April 26, 2026.
+
+ -  Fixed a Mastodon API compatibility regression where replies to local posts
+    were stored as `status` notifications, causing clients to show generic
+    “posted” titles instead of reply notifications.  Replies are now stored as
+    `mention` notifications.  [[#380]]
+
+[#380]: https://github.com/fedify-dev/hollo/issues/380
+
+
 Version 0.7.12
 --------------
 

src/federation/inbox.ts

@@ -36,7 +36,7 @@ import {
   createQuotedUpdateNotifications,
   createQuoteNotification,
   createReblogNotification,
-  createStatusNotification,
+  createReplyMentionNotification,
 } from "../notification";
 import {
   type Account,
@@ -485,12 +485,14 @@ export async function onPostCreated(
     refreshActorIfStale(db, post.account, ctx.origin, ctx);
   }
 
-  // Create status notification for reply target author (if this is a reply)
+  // Create mention notification for reply target author (if this is a reply)
   // and mention notifications for other mentioned local users
   if (post != null) {
     let replyTargetAuthorId: typeof post.accountId | null = null;
 
-    // If this is a reply, create a "status" notification for the original post author
+    // If this is a reply, create a "mention" notification for the original
+    // post author. Mastodon clients render this as a reply based on the
+    // attached status's in_reply_to_account_id.
     if (post.replyTargetId != null) {
       const replyTarget = await db.query.posts.findFirst({
         where: eq(posts.id, post.replyTargetId),
@@ -502,13 +504,12 @@ export async function onPostCreated(
       if (replyTarget != null) {
         replyTargetAuthorId = replyTarget.accountId;
 
-        // Create status notification for the reply target author
-        await createStatusNotification(post.account, post, replyTarget);
+        await createReplyMentionNotification(post.account, post, replyTarget);
       }
     }
 
     // Create mention notifications for mentioned local users
-    // Skip the reply target author since they already got a "status" notification
+    // Skip the reply target author since they already got a reply mention.
     if (post.mentions.length > 0) {
       const mentionedAccountsWithOwners = await db.query.accounts.findMany({
         where: inArray(

src/notification.test.ts

@@ -5,8 +5,10 @@ import { cleanDatabase } from "../tests/helpers";
 import { createAccount } from "../tests/helpers/oauth";
 import db from "./db";
 import {
+  createMentionNotifications,
   createQuotedUpdateNotifications,
   createQuoteNotification,
+  createReplyMentionNotification,
 } from "./notification";
 import * as Schema from "./schema";
 import type { Uuid } from "./uuid";
@@ -51,7 +53,10 @@ async function createRemoteAccount(username: string): Promise<Schema.Account> {
 async function createPost(
   accountId: Uuid,
   content: string,
-  quoteTargetId?: Uuid,
+  options: {
+    quoteTargetId?: Uuid;
+    replyTargetId?: Uuid;
+  } = {},
 ): Promise<Schema.Post> {
   const postId = crypto.randomUUID() as Uuid;
   const postIri = `https://test.example/@test/${postId}`;
@@ -65,14 +70,107 @@ async function createPost(
       accountId,
       visibility: "public",
       content,
-      quoteTargetId,
+      quoteTargetId: options.quoteTargetId,
+      replyTargetId: options.replyTargetId,
       published: new Date(),
     })
     .returning();
 
   return post;
 }
 
+describe("Reply mention notifications", () => {
+  let localAccount: Awaited<ReturnType<typeof createAccount>>;
+  let remoteAccount: Schema.Account;
+
+  beforeEach(async () => {
+    await cleanDatabase();
+    localAccount = await createAccount();
+    remoteAccount = await createRemoteAccount("remote_user");
+  });
+
+  it("creates mention notifications for replies to local posts", async () => {
+    expect.assertions(5);
+
+    const originalPost = await createPost(
+      localAccount.id as Uuid,
+      "Original post",
+    );
+    const replyPost = await createPost(remoteAccount.id, "Reply", {
+      replyTargetId: originalPost.id,
+    });
+
+    const originalPostWithAccount = await db.query.posts.findFirst({
+      where: eq(Schema.posts.id, originalPost.id),
+      with: {
+        account: { with: { owner: true } },
+      },
+    });
+
+    const notificationId = await createReplyMentionNotification(
+      remoteAccount,
+      replyPost,
+      originalPostWithAccount!,
+    );
+
+    expect(notificationId).not.toBeNull();
+
+    const notification = await db.query.notifications.findFirst({
+      where: eq(Schema.notifications.id, notificationId!),
+    });
+
+    expect(notification).not.toBeNull();
+    expect(notification?.type).toBe("mention");
+    expect(notification?.actorAccountId).toBe(remoteAccount.id);
+    expect(notification?.targetPostId).toBe(replyPost.id);
+  });
+
+  it("does not duplicate reply mention notifications when the reply also mentions the original author", async () => {
+    expect.assertions(2);
+
+    const originalPost = await createPost(
+      localAccount.id as Uuid,
+      "Original post",
+    );
+    const replyPost = await createPost(remoteAccount.id, "Reply", {
+      replyTargetId: originalPost.id,
+    });
+
+    const originalPostWithAccount = await db.query.posts.findFirst({
+      where: eq(Schema.posts.id, originalPost.id),
+      with: {
+        account: { with: { owner: true } },
+      },
+    });
+    const mentionedAccount = await db.query.accounts.findFirst({
+      where: eq(Schema.accounts.id, localAccount.id as Uuid),
+      with: { owner: true },
+    });
+
+    await createReplyMentionNotification(
+      remoteAccount,
+      replyPost,
+      originalPostWithAccount!,
+    );
+    const mentionNotificationIds = await createMentionNotifications(
+      replyPost,
+      [mentionedAccount!],
+      originalPost.accountId,
+    );
+
+    expect(mentionNotificationIds).toHaveLength(0);
+
+    const notifications = await db.query.notifications.findMany({
+      where: and(
+        eq(Schema.notifications.type, "mention"),
+        eq(Schema.notifications.targetPostId, replyPost.id),
+      ),
+    });
+
+    expect(notifications).toHaveLength(1);
+  });
+});
+
 describe("Quote notifications", () => {
   let localAccount: Awaited<ReturnType<typeof createAccount>>;
   let remoteAccount: Schema.Account;
@@ -104,11 +202,9 @@ describe("Quote notifications", () => {
       expect(originalPostWithAccount).not.toBeNull();
 
       // Create quote post by remote user
-      const quotePost = await createPost(
-        remoteAccount.id,
-        "Quoting this!",
-        originalPost.id,
-      );
+      const quotePost = await createPost(remoteAccount.id, "Quoting this!", {
+        quoteTargetId: originalPost.id,
+      });
 
       // Create quote notification
       const notificationId = await createQuoteNotification(
@@ -157,7 +253,7 @@ describe("Quote notifications", () => {
       const quotePost = await createPost(
         localAccount.id as Uuid,
         "Quoting my own post",
-        originalPost.id,
+        { quoteTargetId: originalPost.id },
       );
 
       // Create quote notification - should return null for self-quote
@@ -188,11 +284,9 @@ describe("Quote notifications", () => {
       const anotherRemote = await createRemoteAccount("another_remote");
 
       // Create quote post
-      const quotePost = await createPost(
-        anotherRemote.id,
-        "Quoting remote",
-        originalPost.id,
-      );
+      const quotePost = await createPost(anotherRemote.id, "Quoting remote", {
+        quoteTargetId: originalPost.id,
+      });
 
       // Create quote notification - should return null (original author not local)
       const notificationId = await createQuoteNotification(
@@ -213,11 +307,9 @@ describe("Quote notifications", () => {
       const originalPost = await createPost(remoteAccount.id, "Original post");
 
       // Local user creates a quote post
-      const quotePost = await createPost(
-        localAccount.id as Uuid,
-        "My quote",
-        originalPost.id,
-      );
+      const quotePost = await createPost(localAccount.id as Uuid, "My quote", {
+        quoteTargetId: originalPost.id,
+      });
 
       // Get local account with owner info
       const quoteAuthor = await db.query.accounts.findFirst({
@@ -309,11 +401,9 @@ describe("Quote notifications", () => {
       });
 
       // Create quote post by remote user
-      const quotePost = await createPost(
-        remoteAccount.id,
-        "Quoting this!",
-        originalPost.id,
-      );
+      const quotePost = await createPost(remoteAccount.id, "Quoting this!", {
+        quoteTargetId: originalPost.id,
+      });
 
       // Create quote notification twice
       const notificationId1 = await createQuoteNotification(

src/notification.ts

@@ -259,10 +259,11 @@ export async function createReblogNotification(
 }
 
 /**
- * Creates a status notification when someone posts a reply to a user's post.
- * This is different from mention - it specifically means "someone replied to your post".
+ * Creates a mention notification when someone replies to a user's post.
+ * Mastodon clients render reply notifications from mention notifications
+ * whose status points back to the current account via in_reply_to_account_id.
  */
-export async function createStatusNotification(
+export async function createReplyMentionNotification(
   replier: Account,
   replyPost: Post,
   originalPost: Post & { account: Account & { owner: AccountOwner | null } },
@@ -279,7 +280,7 @@ export async function createStatusNotification(
 
   return await createNotification({
     accountOwnerId: originalPost.account.owner.id,
-    type: "status",
+    type: "mention",
     actorAccountId: replier.id,
     targetPostId: replyPost.id,
   });
@@ -306,10 +307,9 @@ export async function createMentionNotifications(
       continue;
     }
 
-    // Skip mention notification for the reply target author to avoid duplicates.
-    // When someone replies to a post and mentions the original author,
-    // they will receive a "status" notification for the reply, so we don't
-    // need to send a separate "mention" notification for the same post.
+    // Skip explicit mention notification for the reply target author to avoid
+    // duplicates. Reply notifications are already represented as "mention"
+    // notifications for Mastodon API compatibility.
     if (replyTargetAuthorId != null && mentioned.id === replyTargetAuthorId) {
       logger.debug(
         "Skipping mention notification for reply target author {accountId} on post {postId}",