chat-app/backend/dist/services/chatService.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ChatService = void 0;
const database_js_1 = require("../config/database.js");
class ChatService {
    static async getChatRooms(userId) {
        try {
            const chatRooms = await database_js_1.prisma.chatRoom.findMany({
                where: {
                    members: {
                        some: {
                            userId,
                        },
                    },
                },
                include: {
                    members: {
                        include: {
                            user: {
                                select: {
                                    id: true,
                                    username: true,
                                    isOnline: true,
                                    avatar: true,
                                },
                            },
                        },
                    },
                    _count: {
                        select: {
                            messages: true,
                        },
                    },
                },
                orderBy: {
                    updatedAt: "desc",
                },
            });
            return {
                success: true,
                data: chatRooms,
            };
        }
        catch (error) {
            console.error("Get chat rooms error:", error);
            return {
                success: false,
                error: "Failed to retrieve chat rooms",
            };
        }
    }
    static async createChatRoom(userId, data) {
        try {
            const chatRoom = await database_js_1.prisma.chatRoom.create({
                data: {
                    name: data.name,
                    description: data.description,
                    createdBy: userId,
                    members: {
                        create: [
                            {
                                userId,
                                role: "admin",
                            },
                        ],
                    },
                },
            });
            if (data.memberUsernames.length > 0) {
                const users = await database_js_1.prisma.user.findMany({
                    where: {
                        username: {
                            in: data.memberUsernames,
                        },
                    },
                });
                const memberData = users.map((user) => ({
                    userId: user.id,
                    roomId: chatRoom.id,
                }));
                await database_js_1.prisma.chatRoomMember.createMany({
                    data: memberData,
                    skipDuplicates: true,
                });
            }
            const fullChatRoom = await database_js_1.prisma.chatRoom.findUnique({
                where: { id: chatRoom.id },
                include: {
                    members: {
                        include: {
                            user: {
                                select: {
                                    id: true,
                                    username: true,
                                    isOnline: true,
                                    avatar: true,
                                },
                            },
                        },
                    },
                    _count: {
                        select: {
                            messages: true,
                        },
                    },
                },
            });
            return {
                success: true,
                data: fullChatRoom,
            };
        }
        catch (error) {
            console.error("Create chat room error:", error);
            return {
                success: false,
                error: "Failed to create chat room",
            };
        }
    }
    static async getMessages(query) {
        try {
            const page = Number.parseInt(query.page ?? "1");
            const limit = Number.parseInt(query.limit ?? "50");
            const skip = (page - 1) * limit;
            const messages = await database_js_1.prisma.message.findMany({
                where: {
                    roomId: query.roomId,
                },
                include: {
                    user: {
                        select: {
                            id: true,
                            username: true,
                            avatar: true,
                        },
                    },
                    reactions: {
                        include: {
                            user: {
                                select: {
                                    id: true,
                                    username: true,
                                },
                            },
                        },
                    },
                },
                orderBy: {
                    createdAt: "desc",
                },
                take: limit,
                skip,
            });
            return {
                success: true,
                data: messages.reverse(),
            };
        }
        catch (error) {
            console.error("Get messages error:", error);
            return {
                success: false,
                error: "Failed to retrieve messages",
            };
        }
    }
    static async checkRoomMembership(userId, roomId) {
        try {
            const membership = await database_js_1.prisma.chatRoomMember.findUnique({
                where: {
                    userId_roomId: {
                        userId,
                        roomId,
                    },
                },
            });
            return !!membership;
        }
        catch (error) {
            console.error("Check room membership error:", error);
            return false;
        }
    }
}
exports.ChatService = ChatService;