feat: enhance notification system with improved display and payload handling

- Introduced new functions for displaying notification content, including actor names and reaction labels.
- Updated notification payload structure to include additional fields like gist_title.
- Enhanced notification body formatting for better user experience.
- Refactored comment creation logic to streamline notification sending process.
- Added Bengali translations for new notification messages to support localization.

This update improves the clarity and usability of notifications within the application.

Author: kingRayhan

src/app/dashboard/notifications/page.tsx

@@ -269,7 +269,8 @@ export type NotificationType =
   | "REPLY_TO_COMMENT"
   | "COMMENT_ON_GIST"
   | "REACTION_ON_ARTICLE"
-  | "REACTION_ON_COMMENT";
+  | "REACTION_ON_COMMENT"
+  | "REACTION_ON_GIST";
 
 export interface NotificationPayload {
   article_id?: string;
@@ -278,6 +279,7 @@ export interface NotificationPayload {
   article_author_username?: string;
   comment_id?: string;
   gist_id?: string;
+  gist_title?: string;
   reaction_type?: string;
   actor_name?: string;
   actor_username?: string;

src/backend/models/domain-models.ts

@@ -0,0 +1,67 @@
+import { eq } from "sqlkit";
+import { persistenceRepository } from "../persistence/persistence-repositories";
+
+/** Walks parent COMMENT chain to the root ARTICLE or GIST for notification payloads and links. */
+export async function commentThreadRootResource(commentId: string): Promise<
+  | {
+      kind: "ARTICLE";
+      article_id: string;
+      article_handle: string;
+      article_title: string;
+      article_author_username?: string;
+    }
+  | { kind: "GIST"; gist_id: string; gist_title: string }
+  | null
+> {
+  let currentId: string | undefined = commentId;
+  for (let depth = 0; depth < 50 && currentId; depth++) {
+    const [row] = await persistenceRepository.comment.find({
+      where: eq("id", currentId),
+      limit: 1,
+      columns: ["resource_id", "resource_type"],
+    });
+    if (!row) return null;
+    const { resource_id, resource_type } = row;
+    if (resource_type === "ARTICLE") {
+      const [article] = await persistenceRepository.article.find({
+        where: eq("id", resource_id),
+        limit: 1,
+        columns: ["id", "author_id", "title", "handle"],
+      });
+      if (!article) return null;
+      const [articleAuthor] = await persistenceRepository.user.find({
+        where: eq("id", article.author_id),
+        limit: 1,
+        columns: ["username"],
+      });
+      return {
+        kind: "ARTICLE",
+        article_id: article.id,
+        article_handle: article.handle,
+        article_title: article.title,
+        ...(articleAuthor?.username
+          ? { article_author_username: articleAuthor.username }
+          : {}),
+      };
+    }
+    if (resource_type === "GIST") {
+      const [gist] = await persistenceRepository.gist.find({
+        where: eq("id", resource_id),
+        limit: 1,
+        columns: ["id", "title"],
+      });
+      if (!gist) return null;
+      return {
+        kind: "GIST",
+        gist_id: gist.id,
+        gist_title: gist.title,
+      };
+    }
+    if (resource_type === "COMMENT") {
+      currentId = resource_id;
+      continue;
+    }
+    return null;
+  }
+  return null;
+}

src/backend/services/comment-thread-root.ts

@@ -3,20 +3,18 @@
 import z from "zod/v4";
 import { CommentActionInput } from "./inputs/comment.input";
 import { authID } from "./session.actions";
-import {
-  ActionException,
-  handleActionException,
-} from "./RepositoryException";
+import { ActionException, handleActionException } from "./RepositoryException";
 import { persistenceRepository } from "../persistence/persistence-repositories";
 import { pgClient } from "../persistence/clients";
 import { and, eq, inArray } from "sqlkit";
 import { CommentPresentation } from "../models/domain-models";
 import { inngest } from "@/lib/inngest";
+import { assertCommentResourceExists } from "./notifications.payload";
 
 const sql = String.raw;
 
 export const getComments = async (
-  _input: z.infer<typeof CommentActionInput.getComments>
+  _input: z.infer<typeof CommentActionInput.getComments>,
 ): Promise<CommentPresentation[]> => {
   const input = CommentActionInput.getComments.parse(_input);
 
@@ -28,71 +26,22 @@ export const getComments = async (
     input.resource_id,
     input.resource_type,
   ]);
-  const rows = execution_response as { rows?: { comments?: CommentPresentation[] }[] };
+  const rows = execution_response as {
+    rows?: { comments?: CommentPresentation[] }[];
+  };
   return rows?.rows?.[0]?.comments || [];
 };
 
 export const createMyComment = async (
-  input: z.infer<typeof CommentActionInput.create>
+  input: z.infer<typeof CommentActionInput.create>,
 ) => {
   const sessionId = await authID();
   if (!sessionId) {
     throw new ActionException("Unauthorized: No session ID found");
   }
   const { resource_id, resource_type, body } = input;
 
-  let notificationRecipientId: string | null = null;
-  let notificationPayload: Record<string, string> = {};
-
-  switch (resource_type) {
-    case "ARTICLE": {
-      const [article] = await persistenceRepository.article.find({
-        where: eq("id", resource_id),
-        limit: 1,
-        columns: ["id", "author_id", "title", "handle"],
-      });
-      if (!article) throw new ActionException("Resource not found");
-      notificationRecipientId = article.author_id;
-      const [articleAuthor] = await persistenceRepository.user.find({
-        where: eq("id", article.author_id),
-        limit: 1,
-        columns: ["id", "username"],
-      });
-      notificationPayload = {
-        article_id: article.id,
-        article_handle: article.handle,
-        article_title: article.title,
-        ...(articleAuthor?.username
-          ? { article_author_username: articleAuthor.username }
-          : {}),
-      };
-      break;
-    }
-    case "COMMENT": {
-      const [parentComment] = await persistenceRepository.comment.find({
-        where: eq("id", resource_id),
-        limit: 1,
-        columns: ["id", "user_id"],
-      });
-      if (!parentComment) throw new ActionException("Parent comment not found");
-      notificationRecipientId = parentComment.user_id;
-      notificationPayload = { comment_id: parentComment.id };
-      break;
-    }
-    case "GIST": {
-      const [gist] = await persistenceRepository.gist.find({
-        where: eq("id", resource_id),
-        limit: 1,
-        columns: ["id", "owner_id", "title"],
-      });
-      if (!gist) throw new ActionException("Resource not found");
-      notificationRecipientId = gist.owner_id;
-      notificationPayload = { gist_id: gist.id };
-      break;
-    }
-    default:
-      throw new ActionException("Invalid resource type");
-  }
+  await assertCommentResourceExists(resource_id, resource_type);
 
   const created = await persistenceRepository.comment.insert([
     {
@@ -104,45 +53,26 @@ export const createMyComment = async (
     },
   ]);
 
-  // Fetch actor info for notification payload
-  const [actor] = await persistenceRepository.user.find({
-    where: eq("id", sessionId),
-    limit: 1,
-    columns: ["id", "name", "username"],
-  });
-
-  // Send notification event (log errors, don't fail the mutation)
-  if (notificationRecipientId) {
-    const notificationType =
-      resource_type === "ARTICLE"
-        ? "COMMENT_ON_ARTICLE"
-        : resource_type === "COMMENT"
-          ? "REPLY_TO_COMMENT"
-          : "COMMENT_ON_GIST";
-    inngest
-      .send({
-        name: "app/notification.requested",
-        data: {
-          recipient_id: notificationRecipientId,
-          actor_id: sessionId,
-          type: notificationType,
-          payload: {
-            ...notificationPayload,
-            actor_name: actor?.name,
-            actor_username: actor?.username,
-          },
+  inngest
+    .send({
+      name: "app/notification.requested",
+      data: {
+        actor_id: sessionId,
+        comment_request: {
+          resource_id,
+          resource_type,
         },
-      })
-      .catch((err) => {
-        console.error("[inngest] Failed to send notification event:", err);
-      });
-  }
+      },
+    })
+    .catch((err) => {
+      console.error("[inngest] Failed to send notification event:", err);
+    });
 
   return created?.rows?.[0];
 };
 
 export const updateMyComment = async (
-  _input: z.infer<typeof CommentActionInput.update>
+  _input: z.infer<typeof CommentActionInput.update>,
 ) => {
   try {
     const input = await CommentActionInput.update.parseAsync(_input);
@@ -175,7 +105,7 @@ export const updateMyComment = async (
 
 /** Deletes the comment and all nested replies; reactions on those comments are removed first. */
 export const deleteMyComment = async (
-  _input: z.infer<typeof CommentActionInput.delete>
+  _input: z.infer<typeof CommentActionInput.delete>,
 ) => {
   try {
     const input = await CommentActionInput.delete.parseAsync(_input);
@@ -212,10 +142,7 @@ export const deleteMyComment = async (
     }
 
     await persistenceRepository.reaction.delete({
-      where: and(
-        eq("resource_type", "COMMENT"),
-        inArray("resource_id", ids)
-      ),
+      where: and(eq("resource_type", "COMMENT"), inArray("resource_id", ids)),
     });
 
     await persistenceRepository.comment.delete({

src/backend/services/comment.action.ts

@@ -1,5 +1,7 @@
 "use server";
 
+/** User-facing server actions. Worker-side payload assembly lives in `notifications.payload.ts`. */
+
 import z from "zod/v4";
 import { and, eq } from "sqlkit";
 import { NotificationActionInput } from "./inputs/notification.input";
@@ -13,7 +15,7 @@ import { Notification } from "../models/domain-models";
 const sql = String.raw;
 
 export async function listMyNotifications(
-  _input: z.infer<typeof NotificationActionInput.list>
+  _input: z.infer<typeof NotificationActionInput.list>,
 ) {
   try {
     const userId = await authID();
@@ -27,7 +29,10 @@ export async function listMyNotifications(
       FROM notifications
       WHERE recipient_id = $1
     `;
-    const countResult = await pgClient.executeSQL<{ total: string }>(countQuery, [userId]);
+    const countResult = await pgClient.executeSQL<{ total: string }>(
+      countQuery,
+      [userId],
+    );
     const totalCount = Number(countResult?.rows?.[0]?.total ?? 0);
     const totalPages = Math.ceil(totalCount / input.limit);
 
@@ -75,7 +80,7 @@ export async function listMyNotifications(
 }
 
 export async function markNotificationRead(
-  _input: z.infer<typeof NotificationActionInput.markRead>
+  _input: z.infer<typeof NotificationActionInput.markRead>,
 ): Promise<ActionResponse<{ id: string }>> {
   try {
     const userId = await authID();
@@ -127,7 +132,9 @@ export async function unreadNotificationCount(): Promise<
       FROM notifications
       WHERE recipient_id = $1 AND read_at IS NULL
     `;
-    const result = await pgClient.executeSQL<{ count: string }>(query, [userId]);
+    const result = await pgClient.executeSQL<{ count: string }>(query, [
+      userId,
+    ]);
     const count = Number(result?.rows?.[0]?.count ?? 0);
 
     return { success: true, data: { count } };