SOlution 1.0

src/controllers/room.controller.js

@@ -0,0 +1,153 @@
+import { messageService } from '../services/message.service.js';
+import { roomService } from '../services/room.service.js';
+import { Message } from '../data/message.js';
+import { userService } from '../services/user.service.js';
+
+const getRoomInfoByRoomId = async (req, res) => {
+  const { roomId } = req.params;
+
+  const id = parseInt(roomId, 10);
+
+  if (isNaN(id)) {
+    return res.status(400).json({ message: 'Invalid roomId' });
+  }
+
+  const room = await roomService.findRoomById(id);
+
+  if (!room) {
+    return res.status(404).json({ message: 'Room not Found' });
+  }
+
+  const messages = await messageService.findRoomsMessages(id);
+
+  return res.status(200).json({
+    room: {
+      id: room.id,
+      name: room.name,
+    },
+    messages,
+  });
+};
+
+const createRoom = async (req, res) => {
+  const { name } = req.body;
+  const user = req.user;
+
+  if (!name) {
+    return res.status(400).json({ message: 'Room name is required' });
+  }
+
+  const newRoom = await roomService.createRoom(name);
+
+  if (!newRoom) {
+    return res.status(400).json({ message: 'Cannot create the room' });
+  }
+
+  await newRoom.addUser(user);
+
+  const roomUsers = await newRoom.getUsers();
+  const roomInfo = {
+    room: { id: newRoom.id, name: newRoom.name },
+    members: roomUsers,
+  };
+
+  return res.status(201).json(roomInfo);
+};
+
+const deleteRoom = async (req, res) => {
+  const { roomId } = req.params;
+  const room = await roomService.findRoomById(roomId);
+
+  if (!roomId || !room) {
+    return res.status(404).json({ message: 'Room not Found' });
+  }
+
+  await room.setUsers([]);
+  await Message.destroy({ where: { roomId: room.id } });
+  await room.destroy();
+
+  res.status(200).json({ message: 'Room deleted successfully' });
+};
+
+const renameRoom = async (req, res) => {
+  const room = req.room;
+  const { newName } = req.body;
+
+  if (!room) {
+    return res.status(404).json({ message: 'Room not Found' });
+  }
+
+  if (!newName || typeof newName !== 'string' || !newName.trim()) {
+    return res.status(400).json({ message: 'Invalid room name provided' });
+  }
+
+  room.name = newName.trim();
+  await room.save();
+
+  return res.status(200).json(room);
+};
+
+const mergeRooms = async (req, res) => {
+  const currentRoom = req.room;
+  const user = req.user;
+  const { targetRoomId } = req.body;
+
+  if (!user) {
+    return res.status(401).json({ error: 'User not authenticated' });
+  }
+
+  if (!currentRoom) {
+    return res.status(404).json({ error: 'Current room not found' });
+  }
+
+  if (!targetRoomId) {
+    return res.status(400).json({ error: 'No targetRoomId provided' });
+  }
+
+  const targetRoomIdNum = parseInt(targetRoomId, 10);
+
+  if (Number.isNaN(targetRoomIdNum)) {
+    return res.status(400).json({ error: 'Invalid targetRoomId' });
+  }
+
+  const usersRooms = await roomService.findRoomsByUserId(user.id);
+  const targetRoom = usersRooms.find((r) => r.id === targetRoomIdNum);
+
+  if (!targetRoom) {
+    return res
+      .status(403)
+      .json({ error: 'The user doesn’t have access to the target room' });
+  }
+
+  await userService.mergeUsers(currentRoom.id, targetRoomIdNum);
+  await messageService.mergeMessages(currentRoom.id, targetRoomIdNum);
+
+  await currentRoom.setUsers([]);
+  await currentRoom.destroy();
+
+  return res.status(200).json(targetRoom);
+};
+
+const joinRoom = async (req, res) => {
+  const { roomId } = req.params;
+  const userId = req.user.id;
+
+  const room = await roomService.findRoomById(roomId);
+
+  if (!room) {
+    return res.status(404).json({ message: 'Room not found' });
+  }
+
+  await roomService.addUserToRoom(userId, roomId);
+
+  return res.status(200).json({ message: 'Joined room successfully' });
+};
+
+export const roomController = {
+  getRoomInfoByRoomId,
+  createRoom,
+  deleteRoom,
+  renameRoom,
+  mergeRooms,
+  joinRoom,
+};

src/controllers/user.controller.js

@@ -0,0 +1,76 @@
+import { roomService } from '../services/room.service.js';
+import { userService } from '../services/user.service.js';
+
+const createUser = async (req, res) => {
+  const { name } = req.body;
+
+  if (!name) {
+    return res.status(400).json({ message: 'Name is required' });
+  }
+
+  const newUser = await userService.createUser(name);
+
+  res.status(201).json(newUser);
+};
+
+const getUserInfo = async (req, res) => {
+  const { userId } = req.params;
+
+  if (!userId) {
+    return res.status(400).json({ message: 'Id is required' });
+  }
+
+  const user = await userService.getUserById(userId);
+
+  if (!user) {
+    return res.status(404).json({ message: 'User not found' });
+  }
+
+  const rooms = await roomService.findRoomsByUserId(user.id);
+  const userInfo = {
+    user: { id: user.id, name: user.name, createdAt: user.createdAt },
+    rooms,
+  };
+
+  res.status(200).json(userInfo);
+};
+
+const changeUserName = async (req, res) => {
+  const user = req.user;
+  const { newName } = req.body;
+
+  if (!user) {
+    return res.status(404).json({ message: 'User not Found' });
+  }
+
+  if (!newName) {
+    return res.status(400).json({ message: 'No new name provided' });
+  }
+
+  user.name = newName;
+
+  await user.save();
+
+  res.status(200).json({ id: user.id, userName: user.name });
+};
+
+const deleteUser = async (req, res) => {
+  const user = req.user;
+
+  if (!user) {
+    return res.status(404).json({ message: 'User not Found' });
+  }
+
+  await user.destroy();
+
+  req.user = null;
+
+  res.status(200).json({ message: 'User deleted successfully' });
+};
+
+export const userController = {
+  createUser,
+  getUserInfo,
+  changeUserName,
+  deleteUser,
+};

src/createServer.js

@@ -0,0 +1,31 @@
+import express from 'express';
+import cors from 'cors';
+
+import { userRouter } from './routes/user.router.js';
+import { roomRouter } from './routes/room.router.js';
+
+export function createServer() {
+  const server = express();
+
+  server.use(express.json());
+
+  server.use(
+    cors({
+      origin: process.env.CLIENT_ORIGIN || 'http://localhost:3000',
+      credentials: true,
+    }),
+  );
+
+  server.get('/', (req, res) => {
+    res.status(200).json({ message: 'Server is running' });
+  });
+
+  server.use('/user', userRouter);
+  server.use('/room', roomRouter);
+
+  server.use((req, res, next) => {
+    res.status(404).json({ message: 'Route not found' });
+  });
+
+  return server;
+}

src/data/associations.js

@@ -0,0 +1,12 @@
+import { User } from './user.js';
+import { Message } from './message.js';
+import { Room } from './room.js';
+
+User.hasMany(Message, { foreignKey: 'userId' });
+Message.belongsTo(User, { foreignKey: 'userId' });
+
+Room.hasMany(Message, { foreignKey: 'roomId' });
+Message.belongsTo(Room, { foreignKey: 'roomId' });
+
+User.belongsToMany(Room, { through: 'user_room', foreignKey: 'userId' });
+Room.belongsToMany(User, { through: 'user_room', foreignKey: 'roomId' });

src/data/message.js

@@ -0,0 +1,29 @@
+import { DataTypes } from 'sequelize';
+import { client } from '../db/db.js';
+
+export const Message = client.define(
+  'Message',
+  {
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      autoIncrement: true,
+    },
+    roomId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    userId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    text: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+  },
+  {
+    timestamps: true,
+    tableName: 'messages',
+  },
+);

src/data/room.js

@@ -0,0 +1,22 @@
+import { DataTypes } from 'sequelize';
+import { client } from '../db/db.js';
+
+export const Room = client.define(
+  'Room',
+  {
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      autoIncrement: true,
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+  },
+  {
+    timestamps: true,
+    tableName: 'rooms',
+  },
+);

src/data/user.js

@@ -0,0 +1,22 @@
+import { DataTypes } from 'sequelize';
+import { client } from '../db/db.js';
+
+export const User = client.define(
+  'User',
+  {
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      autoIncrement: true,
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+  },
+  {
+    timestamps: true,
+    tableName: 'users',
+  },
+);

src/db/db.init.js

@@ -0,0 +1,17 @@
+import { client } from './db.js';
+import '../data/associations.js';
+
+export const dbInit = async () => {
+  await client.authenticate();
+  // eslint-disable-next-line no-console
+  console.log('✅ Database connected');
+
+  await client.sync({ alter: true });
+  // eslint-disable-next-line no-console
+  console.log('✅ Tables synced');
+
+  const tables = await client.getQueryInterface().showAllTables();
+
+  // eslint-disable-next-line no-console
+  console.log(tables);
+};

src/db/db.js

@@ -0,0 +1,10 @@
+import { Sequelize } from 'sequelize';
+
+export const client = new Sequelize({
+  database: 'postgres',
+  username: 'postgres',
+  host: 'localhost',
+  dialect: 'postgres',
+  port: 5432,
+  password: 'Rerlol100',
+});