feat(chat): DMs done (#108)

Author: MarioRaafat

src/auth/auth.module.ts

@@ -11,8 +11,6 @@ import { GitHubStrategy } from './strategies/github.strategy';
 import { CaptchaService } from './captcha.service';
 import { UsernameService } from './username.service';
 import { UserModule } from 'src/user/user.module';
-import { RedisModule } from '@nestjs-modules/ioredis';
-import { RedisService } from 'src/redis/redis.service';
 import { VerificationModule } from 'src/verification/verification.module';
 import { CommunicationModule } from 'src/communication/communication.module';
 import { EmailService } from 'src/communication/email.service';
@@ -39,7 +37,6 @@ import { EmailJobsService } from 'src/background-jobs/email/email.service';
         }),
         PassportModule,
         UserModule,
-        RedisModule,
         VerificationModule,
         CommunicationModule,
         BackgroundJobsModule,
@@ -50,7 +47,6 @@ import { EmailJobsService } from 'src/background-jobs/email/email.service';
         JwtStrategy,
         GitHubStrategy,
         UserRepository,
-        RedisService,
         VerificationService,
         EmailService,
         EmailJobsService,

src/auth/auth.service.ts

@@ -114,6 +114,7 @@ export class AuthService {
             if (!unverified_user) {
                 throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
             } else {
+                console.log(`pass ${password} vs ${unverified_user.password}`);
                 const is_password_valid = await bcrypt.compare(password, unverified_user.password);
                 if (!is_password_valid) {
                     throw new UnauthorizedException(ERROR_MESSAGES.WRONG_PASSWORD);

src/chat/chat.module.ts

@@ -12,5 +12,6 @@ import { Message } from '../messages/entities/message.entity';
 
     controllers: [ChatController],
     providers: [ChatService, ChatRepository, PaginationService],
+    exports: [ChatRepository],
 })
 export class ChatModule {}

src/messages/messages.controller.ts

@@ -24,6 +24,7 @@ import {
     get_messages_swagger,
     send_message_swagger,
     update_message_swagger,
+    websocket_docs_swagger,
 } from './messages.swagger';
 import { MessagesService } from './messages.service';
 import { JwtAuthGuard } from 'src/auth/guards/jwt.guard';
@@ -35,6 +36,39 @@ import { JwtAuthGuard } from 'src/auth/guards/jwt.guard';
 export class MessagesController {
     constructor(private readonly messages_service: MessagesService) {}
 
+    @ApiOperation(websocket_docs_swagger.operation)
+    @ApiOkResponse(websocket_docs_swagger.responses.success)
+    @Get('websocket-docs')
+    async socketDocs() {
+        return {
+            message: 'WebSocket documentation available in Swagger UI',
+            namespace: '/messages',
+            events: {
+                client_to_server: [
+                    'join_chat',
+                    'leave_chat',
+                    'send_message',
+                    'update_message',
+                    'delete_message',
+                    'typing_start',
+                    'typing_stop',
+                ],
+                server_to_client: [
+                    'unread_chats_summary',
+                    'new_message',
+                    'message_updated',
+                    'message_deleted',
+                    'user_typing',
+                    'user_stopped_typing',
+                    'joined_chat',
+                    'left_chat',
+                    'message_sent',
+                    'error',
+                ],
+            },
+        };
+    }
+
     @ApiOperation(send_message_swagger.operation)
     @ApiParam(send_message_swagger.params.chat_id)
     @ApiBody({ type: SendMessageDto })

src/messages/messages.gateway.ts

@@ -12,6 +12,7 @@ import { UseGuards } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { ConfigService } from '@nestjs/config';
 import { MessagesService } from './messages.service';
+import { ChatRepository } from 'src/chat/chat.repository';
 import { GetMessagesQueryDto, SendMessageDto, UpdateMessageDto } from './dto';
 import { WsJwtGuard } from 'src/auth/guards/ws-jwt.guard';
 
@@ -36,6 +37,7 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
     private userSockets = new Map<string, Set<string>>();
     constructor(
         private readonly messages_service: MessagesService,
+        private readonly chat_repository: ChatRepository,
         private readonly jwt_service: JwtService,
         private readonly config_service: ConfigService
     ) {}
@@ -52,12 +54,34 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
             this.userSockets.get(user_id)?.add(client.id);
 
             console.log(`Client connected: ${client.id} (User: ${user_id})`);
+
+            // Send unread messages count to newly connected client
+            await this.sendUnreadChatsOnConnection(client, user_id);
         } catch (error) {
             console.error('Connection error:', error);
             client.disconnect();
         }
     }
 
+    /**
+     * Notify client about chats with unread messages when they connect
+     * Frontend should then request full message history for these chats
+     */
+    private async sendUnreadChatsOnConnection(client: IAuthenticatedSocket, user_id: string) {
+        try {
+            const unread_chats = await this.messages_service.getUnreadChatsForUser(user_id);
+
+            if (unread_chats.length > 0) {
+                client.emit('unread_chats_summary', {
+                    chats: unread_chats,
+                    message: 'You have unread messages in these chats',
+                });
+            }
+        } catch (error) {
+            console.error('Error sending unread chats on connection:', error);
+        }
+    }
+
     handleDisconnect(client: IAuthenticatedSocket) {
         const user_id = client.user?.user_id;
         if (user_id) {
@@ -81,7 +105,12 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
             const user_id = client.user!.user_id;
             const { chat_id } = data;
 
-            await this.messages_service.validateChatParticipation(user_id, chat_id);
+            const chat = await this.messages_service.validateChatParticipation(user_id, chat_id);
+
+            // Reset unread count for this user when they join the chat
+            const unread_field =
+                chat.user1_id === user_id ? 'unread_count_user1' : 'unread_count_user2';
+            await this.chat_repository.update({ id: chat_id }, { [unread_field]: 0 });
 
             await client.join(chat_id);
             return {
@@ -128,21 +157,29 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
             const user_id = client.user!.user_id;
             const { chat_id, message } = data;
 
-            const result = await this.messages_service.sendMessage(user_id, chat_id, message);
+            // Check if recipient is actively in the chat room
+            const chat = await this.messages_service.validateChatParticipation(user_id, chat_id);
+            const recipient_id = chat.user1_id === user_id ? chat.user2_id : chat.user1_id;
+            console.log('Recipient ID:', recipient_id);
+            const is_recipient_in_room = await this.isUserInChatRoom(recipient_id, chat_id);
 
-            // Emit to the chat room (for users already in the room)
-            this.server.to(chat_id).emit('new_message', {
-                chat_id: chat_id,
-                message: result,
-            });
+            const result = await this.messages_service.sendMessage(
+                user_id,
+                chat_id,
+                message,
+                is_recipient_in_room
+            );
 
-            // Also emit directly to the recipient (in case they're not in the room yet)
-            const recipient_id = result.recipient_id;
             if (recipient_id) {
                 this.emitToUser(recipient_id, 'new_message', {
                     chat_id,
                     message: result,
                 });
+            } else {
+                this.server.to(chat_id).emit('new_message', {
+                    chat_id,
+                    message: result,
+                });
             }
 
             return {
@@ -157,29 +194,6 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
         }
     }
 
-    @SubscribeMessage('get_messages')
-    async handleGetMessages(
-        @ConnectedSocket() client: IAuthenticatedSocket,
-        @MessageBody() data: { chat_id: string; query?: GetMessagesQueryDto }
-    ) {
-        try {
-            const user_id = client.user!.user_id;
-            const { chat_id, query } = data;
-
-            const messages = await this.messages_service.getMessages(user_id, chat_id, query || {});
-
-            return {
-                event: 'messages_retrieved',
-                data: messages,
-            };
-        } catch (error) {
-            return {
-                event: 'error',
-                data: { message: error.message || 'Failed to retrieve messages' },
-            };
-        }
-    }
-
     @SubscribeMessage('update_message')
     async handleUpdateMessage(
         @ConnectedSocket() client: IAuthenticatedSocket,
@@ -196,11 +210,6 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
                 message_id,
                 update
             );
-            this.server.to(chat_id).emit('message_updated', {
-                chat_id,
-                message_id,
-                message: result,
-            });
 
             const recipient_id = result.recipient_id;
             if (recipient_id) {
@@ -209,6 +218,12 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
                     message_id,
                     message: result,
                 });
+            } else {
+                this.server.to(chat_id).emit('message_updated', {
+                    chat_id,
+                    message_id,
+                    message: result,
+                });
             }
 
             return {
@@ -233,10 +248,6 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
             const { chat_id, message_id } = data;
 
             const result = await this.messages_service.deleteMessage(user_id, chat_id, message_id);
-            this.server.to(chat_id).emit('message_deleted', {
-                chat_id,
-                message_id,
-            });
 
             const recipient_id = result.recipient_id;
             if (recipient_id) {
@@ -245,6 +256,11 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
                     message_id,
                     message: result,
                 });
+            } else {
+                this.server.to(chat_id).emit('message_deleted', {
+                    chat_id,
+                    message_id,
+                });
             }
 
             return {
@@ -322,4 +338,20 @@ export class MessagesGateway implements OnGatewayConnection, OnGatewayDisconnect
             });
         }
     }
+
+    async isUserInChatRoom(user_id: string, chat_id: string): Promise<boolean> {
+        const socket_ids = this.userSockets.get(user_id);
+        if (!socket_ids) return false;
+        // Check if any of the user's sockets are in the chat room
+        const sockets_in_room = await this.server.in(chat_id).fetchSockets();
+        const room_socket_ids = new Set(sockets_in_room.map((s) => s.id));
+
+        for (const socket_id of socket_ids) {
+            if (room_socket_ids.has(socket_id)) {
+                console.log(`User ${user_id} is in chat room ${chat_id} via socket ${socket_id}`);
+                return true;
+            }
+        }
+        return false;
+    }
 }

src/messages/messages.module.ts

@@ -8,6 +8,7 @@ import { Message } from './entities/message.entity';
 import { Chat } from 'src/chat/entities/chat.entity';
 import { MessagesGateway } from './messages.gateway';
 import { JwtModule } from '@nestjs/jwt';
+import { ChatModule } from 'src/chat/chat.module';
 
 @Module({
     imports: [
@@ -16,6 +17,7 @@ import { JwtModule } from '@nestjs/jwt';
             secret: process.env.JWT_TOKEN_SECRET,
             signOptions: { expiresIn: '7d' },
         }),
+        ChatModule,
     ],
     providers: [MessagesService, MessageRepository, PaginationService, MessagesGateway],
     controllers: [MessagesController],

src/messages/messages.repository.ts

@@ -15,14 +15,20 @@ export class MessageRepository extends Repository<Message> {
         super(Message, data_source.createEntityManager());
     }
 
-    async createMessage(sender_id: string, chat_id: string, dto: SendMessageDto): Promise<Message> {
+    async createMessage(
+        sender_id: string,
+        chat_id: string,
+        dto: SendMessageDto,
+        is_read: boolean = false
+    ): Promise<Message> {
         try {
             const message = this.create({
                 sender_id,
                 chat_id,
                 content: dto.content,
                 message_type: dto.message_type || MessageType.TEXT,
                 reply_to_message_id: dto.reply_to_message_id || null,
+                is_read: is_read,
             });
 
             const saved_message = await this.save(message);