Notify clients about updated/received chats

Author: hussein-m-kandil

src/api/v1/chats/chats.router.ts

@@ -6,6 +6,7 @@ import * as Storage from '@/lib/storage';
 import * as Service from './chats.service';
 import * as Middlewares from '@/middlewares';
 import { Request, Response, Router } from 'express';
+import logger from '@/lib/logger';
 
 export const chatsRouter = Router();
 
@@ -28,32 +29,53 @@ chatsRouter.get('/', Middlewares.authValidator, async (req, res) => {
   const userId = Utils.getCurrentUserIdFromReq(req)!;
   const filters = Utils.getBasePaginationFiltersFromReqQuery(req);
   const chats = await Service.getUserChats(userId, filters);
-  res.json(chats);
+  res.json(chats).on('finish', () => {
+    const rooms = Service.getOtherChatsMemberIds(userId, chats);
+    Utils.emitToRoomsIfAny({ rooms, event: 'chats:received', volatile: true });
+  });
 });
 
 chatsRouter.get('/members/:profileId', Middlewares.authValidator, async (req, res) => {
   const userId = Utils.getCurrentUserIdFromReq(req)!;
   const chats = await Service.getUserChatsByMember(userId, req.params.profileId);
-  res.json(chats);
+  res.json(chats).on('finish', () => {
+    const rooms = Service.getOtherChatsMemberIds(userId, chats);
+    Utils.emitToRoomsIfAny({ rooms, event: 'chats:received', volatile: true });
+  });
 });
 
 chatsRouter.get('/:id', Middlewares.authValidator, async (req, res) => {
+  const chatId = req.params.id;
   const userId = Utils.getCurrentUserIdFromReq(req)!;
-  const chat = await Service.getUserChatById(userId, req.params.id);
-  res.json(chat);
+  const chat = await Service.getUserChatById(userId, chatId);
+  res.json(chat).on('finish', () => {
+    Service.getOtherChatMemberIds(userId, chatId)
+      .then((rooms) => Utils.emitToRoomsIfAny({ rooms, event: 'chats:received', volatile: true }))
+      .catch((error: unknown) => logger.error('Failed to broadcast "chats:received"', error));
+  });
 });
 
 chatsRouter.get('/:id/messages', Middlewares.authValidator, async (req, res) => {
+  const chatId = req.params.id;
   const userId = Utils.getCurrentUserIdFromReq(req)!;
   const filters = Utils.getBasePaginationFiltersFromReqQuery(req);
-  const messages = await Service.getUserChatMessages(userId, req.params.id, filters);
-  res.json(messages);
+  const messages = await Service.getUserChatMessages(userId, chatId, filters);
+  res.json(messages).on('finish', () => {
+    Service.getOtherChatMemberIds(userId, chatId)
+      .then((rooms) => Utils.emitToRoomsIfAny({ rooms, event: 'chats:received', volatile: true }))
+      .catch((error: unknown) => logger.error('Failed to broadcast "chats:received"', error));
+  });
 });
 
 chatsRouter.get('/:id/messages/:msgId', Middlewares.authValidator, async (req, res) => {
+  const chatId = req.params.id;
   const userId = Utils.getCurrentUserIdFromReq(req)!;
-  const msg = await Service.getUserChatMessageById(userId, req.params.id, req.params.msgId);
-  res.json(msg);
+  const msg = await Service.getUserChatMessageById(userId, chatId, req.params.msgId);
+  res.json(msg).on('finish', () => {
+    Service.getOtherChatMemberIds(userId, chatId)
+      .then((rooms) => Utils.emitToRoomsIfAny({ rooms, event: 'chats:received', volatile: true }))
+      .catch((error: unknown) => logger.error('Failed to broadcast "chats:received"', error));
+  });
 });
 
 chatsRouter.post(
@@ -67,33 +89,65 @@ chatsRouter.post(
     );
     const preparedImageData = await prepareImageData(req, chatData.message.imagedata, user);
     const createdChat = await Service.createChat(user, chatData, ...preparedImageData);
-    res.status(201).json(createdChat);
+    res
+      .status(201)
+      .json(createdChat)
+      .on('finish', () => {
+        Service.getOtherChatMemberIds(user.id, createdChat.id)
+          .then((rooms) =>
+            Utils.emitToRoomsIfAny({ rooms, event: 'chats:updated', volatile: true }),
+          )
+          .catch((error: unknown) => logger.error('Failed to broadcast "chats:updated"', error));
+      });
   },
 );
 
 chatsRouter.patch('/:id/seen', Middlewares.authValidator, async (req, res) => {
+  const chatId = req.params.id;
   const userId = Utils.getCurrentUserIdFromReq(req)!;
-  res.json(await Service.updateProfileChatLastSeenDate(userId, req.params.id));
+  res.json(await Service.updateProfileChatLastSeenDate(userId, chatId)).on('finish', () => {
+    Service.getOtherChatMemberIds(userId, chatId)
+      .then((rooms) => Utils.emitToRoomsIfAny({ rooms, event: 'chats:updated', volatile: true }))
+      .catch((error: unknown) => logger.error('Failed to broadcast "chats:updated"', error));
+  });
 });
 
 chatsRouter.post(
   '/:id/messages',
   Middlewares.authValidator,
   Middlewares.createFileProcessor('image'),
   async (req: Request, res: Response) => {
+    const chatId = req.params.id;
     const user = Utils.getCurrentUserFromReq(req)!;
     const { imagedata, ...msgData } = (
       req.file ? Schema.optionalMessageSchema : Schema.messageSchema
     ).parse(req.body);
     const preparedImageData = await prepareImageData(req, imagedata, user);
-    const msgArgs = [user, req.params.id, msgData, ...preparedImageData] as const;
+    const msgArgs = [user, chatId, msgData, ...preparedImageData] as const;
     const createdMessage = await Service.createUserChatMessage(...msgArgs);
-    res.status(201).json(createdMessage);
+    res
+      .status(201)
+      .json(createdMessage)
+      .on('finish', () => {
+        Service.getOtherChatMemberIds(user.id, chatId)
+          .then((rooms) =>
+            Utils.emitToRoomsIfAny({ rooms, event: 'chats:updated', volatile: true }),
+          )
+          .catch((error: unknown) => logger.error('Failed to broadcast "chats:updated"', error));
+      });
   },
 );
 
 chatsRouter.delete('/:id', Middlewares.authValidator, async (req, res) => {
+  const chatId = req.params.id;
   const userId = Utils.getCurrentUserIdFromReq(req)!;
-  await Service.deleteChat(userId, req.params.id);
-  res.status(204).send();
+  await Service.deleteChat(userId, chatId);
+  res
+    .status(204)
+    .send()
+    .on('finish', () => {
+      Service.getOtherChatMemberIds(userId, chatId)
+        .then((rooms) => Utils.emitToRoomsIfAny({ rooms, event: 'chats:updated', volatile: true }))
+        .catch((error: unknown) => logger.error('Failed to broadcast "chats:updated"', error));
+    });
 });

src/api/v1/chats/chats.service.ts

@@ -173,9 +173,13 @@ export const deleteChat = async (userId: User['id'], chatId: Chat['id']) => {
         if (chat.profiles.length < 2) {
           await tx.chat.delete({ where: { id: chatId } });
         } else {
-          const profile = chat.profiles.find((p) => p.profile?.userId === userId);
-          if (profile) {
-            const { profileName } = profile;
+          let profileName: string | undefined;
+          const otherMembersIds: string[] = [];
+          for (const cp of chat.profiles) {
+            if (!profileName && cp.profile?.userId === userId) profileName = cp.profileName;
+            else if (cp.profileId) otherMembersIds.push(cp.profileId);
+          }
+          if (profileName) {
             await tx.profilesChats.delete({
               where: { profileName_chatId: { chatId, profileName } },
             });
@@ -241,6 +245,33 @@ export const getUserChatById = async (userId: User['id'], chatId: Chat['id']) =>
   );
 };
 
+export const getOtherChatMemberIds = async (userId: User['id'], chatId: Chat['id']) => {
+  const chat = await db.chat.findUnique({
+    where: { id: chatId },
+    select: { profiles: { select: { profile: true } } },
+  });
+  const otherMembersIds: string[] = [];
+  if (chat) {
+    for (const { profile } of chat.profiles) {
+      if (profile && profile.userId !== userId) otherMembersIds.push(profile.id);
+    }
+  }
+  return otherMembersIds;
+};
+
+export const getOtherChatsMemberIds = (
+  userId: User['id'],
+  chats: Awaited<ReturnType<typeof getUserChats>>,
+) => {
+  const chatsMemberIds: string[] = [];
+  for (const chat of chats) {
+    for (const { profile } of chat.profiles) {
+      if (profile && profile.userId !== userId) chatsMemberIds.push(profile.id);
+    }
+  }
+  return chatsMemberIds;
+};
+
 export const getUserChatsByMember = async (userId: User['id'], memberIdOrUsername: string) => {
   return await Utils.handleDBKnownErrors(
     db.$transaction(async (tx) => {

src/lib/utils.ts

@@ -4,6 +4,7 @@ import * as Storage from '@/lib/storage';
 import * as AppError from '@/lib/app-error';
 import { Prisma } from '@/../prisma/client';
 import { Request } from 'express';
+import { io } from '@/lib/io';
 import { z } from 'zod';
 import ms from 'ms';
 import db from '@/lib/db';
@@ -13,6 +14,10 @@ export const lowerCase = <T extends string>(s: T): Lowercase<T> => {
   return s.toLowerCase() as Lowercase<T>;
 };
 
+export const emitToRoomsIfAny = ({ event, rooms, volatile }: Types.SocketEventData) => {
+  if (rooms.length) (volatile ? io.volatile : io).to(rooms).emit(event);
+};
+
 export const createJwtForUser = (user: Types.PublicUser): string => {
   const { id, isAdmin } = user;
   const payload: Types.AppJwtPayload = { id, isAdmin };

src/types.ts

@@ -156,3 +156,9 @@ export interface EvaluationResult {
   evaluation: Record<string, boolean>;
   finder: CharacterFinder;
 }
+
+export interface SocketEventData {
+  event: string;
+  rooms: string[];
+  volatile?: boolean;
+}