Building Slack-Style Chat from Scratch: Architecture and Trade-offs

Building a production-ready chat system requires more than just sending messages. This deep dive covers the complete implementation from ft_transcendence: a dual-layer messaging architecture with direct messages and group channels, real-time delivery via Socket.io namespaces, role-based moderation with timed bans and mutes, hashed room IDs, blocked user filtering, and message persistence with Prisma and PostgreSQL.

Note: All code examples are taken directly from the actual ft_transcendence codebase. Variable names like recieverId, generateHashedRommId, unbanneTime, and hachedChannelPswd reflect the original source code as-is.

Real-Time Communication Fundamentals

Before diving into the implementation, it is essential to understand the core technologies and concepts that power the chat system.

WebSocket Protocol

Traditional HTTP follows a request-response cycle — the client asks, the server answers, and the connection closes. But chat requires the opposite: the server needs to push messages to clients instantly, without waiting for them to ask. WebSocket solves this by upgrading an HTTP connection into a persistent, full-duplex channel where both sides can send data at any time.

HTTP (Request-Response):
Client ──── GET /messages ────▶ Server
Client ◀──── 200 OK ────────── Server
(connection closed)

WebSocket (Full-Duplex):
Client ──── HTTP Upgrade ────▶ Server
Client ◀──── 101 Switching ── Server
Client ◀────────────────────▶ Server  (persistent, bidirectional)
    

Socket.io & NestJS Gateways

Socket.io builds on top of raw WebSockets and adds critical features for production use: automatic reconnection, fallback to HTTP long-polling, room-based broadcasting, and acknowledgements. In our NestJS backend, Socket.io is integrated through Gateways — classes decorated with @WebSocketGateway that define event handlers using @SubscribeMessage.

// NestJS Gateway Pattern
@WebSocketGateway({ namespace: 'chatGateway' })
export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {

  @WebSocketServer()
  server: Server;

  // Fired when a client connects
  handleConnection(client: Socket): void { ... }

  // Listen for 'message' events from clients
  @SubscribeMessage('message')
  handleMessage(@MessageBody() data: any, @ConnectedSocket() socket: Socket) { ... }

  // Fired when a client disconnects
  handleDisconnect(client: Socket): void { ... }
}
    

Namespaces & Rooms

Socket.io provides two levels of message scoping:

• Namespaces are separate communication channels on the same server. Each namespace has its own set of event handlers, connected clients, and rooms. We use three: /appGateway, /chatGateway, and /channelGateway.
• Rooms are arbitrary groupings within a namespace. A socket can join or leave rooms at any time. When you emit to a room, only sockets in that room receive the message — this is how we scope DMs to two users and channel messages to group members.

Prisma ORM & PostgreSQL

Prisma provides type-safe database access with auto-generated TypeScript types from the schema. Every model in the Prisma schema maps directly to a PostgreSQL table, and relations are enforced at the database level with foreign keys. This means our chat data — messages, channels, memberships — is always consistent and queryable with full type safety.

Chat System Architecture

The ft_transcendence chat system is built on a dual-layer architecture: Direct Messages for 1-on-1 conversations and Channels for group communication. Each layer has its own dedicated Socket.io namespace, service, and gateway — keeping concerns separated and scalable.

+--------------------------------------------------------+
|                       FRONTEND                         |
|                                                        |
| +-----------+ +-----------+ +----------+ +-----------+ |
| |  Chat UI  | |  Channel  | |  Member  | |  Friend   | |
| |  (1-on-1) | |   Room    | |   List   | |   List    | |
| +-----+-----+ +-----+-----+ +----+-----+ +-----+-----+ |
|       |             |            |             |       |
|       +-------------+------------+-------------+       |
|                         |                              |
|           Socket.io Client (3 Namespaces)              |
+----------------------------+---------------------------+
                             |
                        WebSocket
                             |
+----------------------------+---------------------------+
|                      NestJS Backend                    |
|                            |                           |
| +----------------------------------------------------+ |
| |            Socket.io Gateways                      | |
| |                                                    | |
| | /appGateway     - Friends, Invitations, Blocking   | |
| | /chatGateway    - Direct Messages (1-on-1)         | |
| | /channelGateway - Group Channels, Moderation       | |
| +-----------------------+----------------------------+ |
|                         |                              |
| +-----------------------+----------------------------+ |
| |         Services & Client Tracking                | |
| |                                                    | |
| | ChatService         ChannelService                 | |
| | UsersService        ConnectedClientsService        | |
| +-----------------------+----------------------------+ |
|                         |                              |
+----------------------------+---------------------------+
                            |
                       Prisma ORM
                            |
                  +-------------------+
                  |    PostgreSQL      |
                  |                   |
                  |  - User           |
                  |  - DirectMessage  |
                  |  - Channel        |
                  |  - ChannelMember  |
                  |  - BlockedUser    |
                  +-------------------+

Database Schema Design

The schema separates direct messaging from channel-based communication. Direct messages use a SHA-256 hashed room ID derived from both user IDs, while channels support public, protected (password), and private types with granular role-based membership.

Core Models — Users & Direct Messages

enum Status {
  ONLINE
  OFFLINE
  INAGAME
}

model User {
  id                  String    @id @default(uuid())
  name                String?   @unique
  email               String    @unique
  intraId             String    @unique
  Avatar              String?
  status              Status    @default(ONLINE)
  isAuth              Boolean   @default(true)
  twoFactorAuthSecret String?
  isTwoFactorEnabled  Boolean   @default(false)

  // Relations
  userThatBlock       BlockedUser[]    @relation("Bloking")
  blockedUser         BlockedUser[]    @relation("blocked")
  senders             DirectMessage[]  @relation("sendeMessage")
  receivers           DirectMessage[]  @relation("receiveMessage")
  channelOwner        Channel[]        @relation("channelOwner")
  channelMember       ChannelMember[]  @relation("channelMember")
  kickedMember        KickedMember[]   @relation("kickedMember")
  channelMessage      ChannelMessage[] @relation("sendChannelMessage")
  created_at          DateTime         @default(now())
  updated_at          DateTime         @updatedAt
}

model DirectMessage {
  id         String   @id @default(uuid())
  content    String
  sender     User     @relation("sendeMessage", fields: [senderId], references: [id])
  senderId   String
  reciever   User     @relation("receiveMessage", fields: [recieverId], references: [id])
  recieverId String
  roomId     String   // SHA-256 hash of sorted sender+receiver IDs
  seen       Boolean  @default(false)
  created_at DateTime @default(now())
}

model BlockedUser {
  id            String   @id @default(uuid())
  userThatBlock User     @relation("Bloking", fields: [userId], references: [id])
  userId        String
  blockedUser   User     @relation("blocked", fields: [blockedUserId], references: [id])
  blockedUserId String
  created_at    DateTime @default(now())
}
    

Channel Models — Group Communication

enum ChannelType {
  PUBLIC       // Open to all users
  PROTECTED    // Requires password to join
  PRIVATE      // Invite-only via UUID
}

enum Role {
  OWNER
  ADMIN
  MEMBER
  MUTED_MEMBER     // Temporarily silenced
  BANNED_MEMBER    // Temporarily banned
  MUTED_ADMIN      // Admin temporarily silenced
  BANNED_ADMIN     // Admin temporarily banned
}

model Channel {
  id              String           @id @default(uuid())
  channelName     String           @unique
  channelType     ChannelType      @default(PUBLIC)
  channelPassword String?
  created_at      DateTime         @default(now())
  updated_at      DateTime         @updatedAt
  user            User             @relation("channelOwner", fields: [channelOwnerId], references: [id])
  channelOwnerId  String
  channelMember   ChannelMember[]  @relation("channelMember")
  kickedMember    KickedMember[]   @relation("kickedMember")
  recievers       ChannelMessage[] @relation("receiverRelation")
}

model ChannelMember {
  id          String    @id @default(uuid())
  user        User      @relation("channelMember", fields: [userId], references: [id])
  userId      String
  channel     Channel   @relation("channelMember", fields: [channelId], references: [id])
  channelId   String
  role        Role      @default(MEMBER)
  bannedTime  DateTime?
  unbanneTime DateTime?
  mutedTime   DateTime?
  unmuteTime  DateTime?
  created_at  DateTime  @default(now())

  @@unique([userId, channelId], name: "userAndChannel")
}

model KickedMember {
  id         String   @id @default(uuid())
  user       User     @relation("kickedMember", fields: [userId], references: [id])
  userId     String
  channel    Channel  @relation("kickedMember", fields: [channelId], references: [id])
  channelId  String
  created_at DateTime @default(now())

  @@unique([userId, channelId], name: "kickedMemberAndChannel")
}

model ChannelMessage {
  id         String   @id @default(uuid())
  content    String
  sender     User     @relation("sendChannelMessage", fields: [userId], references: [id])
  userId     String
  recievers  Channel  @relation("receiverRelation", fields: [channelId], references: [id])
  channelId  String
  created_at DateTime @default(now())
}
    

Backend Implementation

Connected Clients Service

A centralized service tracks all connected clients across different gateways. Separate maps are maintained for the app gateway and chat gateway, enabling cross-namespace notifications — for example, sending a notification via the app gateway when a message arrives on the chat gateway.

import { Injectable } from '@nestjs/common';
import { Socket } from 'socket.io';
import { PrismaService } from 'prisma/prisma.service';

export const connectedClients: Map<string, string> = new Map();

@Injectable()
export class ConnectedClientsService {

  private connectedClientsInChat: Map<string, string> = new Map();

  constructor(private prisma: PrismaService) {}

  addClient(client: Socket) {
    const userId = client.handshake.auth.userId as string;
    if (userId && client.id) {
      if (!connectedClients.has(client.id)) {
        connectedClients.set(client.id, userId);
      }
    }
  }

  addClientInchat(client: Socket) {
    const userId = client.handshake.auth.userId as string;
    if (userId && client.id) {
      if (!this.connectedClientsInChat.has(client.id)) {
        this.connectedClientsInChat.set(client.id, userId);
      }
    }
  }

  getAllClients(): Map<string, string> {
    return connectedClients;
  }

  getAllClientsFromChat(): Map<string, string> {
    return this.connectedClientsInChat;
  }

  removeClient(client: Socket) {
    connectedClients.delete(client.id);
  }

  removeClientFromChat(client: Socket) {
    this.connectedClientsInChat.delete(client.id);
  }
}
    

Direct Message Service

The chat service handles 1-on-1 messaging with a clever room ID strategy: both user IDs are sorted and joined, then SHA-256 hashed. This ensures the same room ID is generated regardless of which user initiates the conversation — no duplicate rooms, no lookups needed.

import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
import { CreateChatDto } from './dto/create-chat.dto';
import { PrismaService } from '../../prisma/prisma.service';
import { DirectMessage } from '@prisma/client';
import { createHash } from 'crypto';
import { UpdateChatDto } from './dto/update-chat.dto';

@Injectable()
export class ChatService {
  constructor(private prisma: PrismaService) {}

  async generateHashedRommId(
    senderId: string,
    recieverId: string
  ): Promise<string> {
    const roomID = [senderId, recieverId].sort().join('-');
    const hasshedRoomName = createHash('sha256')
      .update(roomID)
      .digest('hex');
    return hasshedRoomName;
  }

  async createChat(createChatDto: CreateChatDto): Promise<DirectMessage> {
    const hasshedRoomName = await this.generateHashedRommId(
      createChatDto.senderId,
      createChatDto.recieverId
    );

    return this.prisma.directMessage.create({
      data: {
        content: createChatDto.content,
        senderId: createChatDto.senderId,
        recieverId: createChatDto.recieverId,
        roomId: hasshedRoomName,
      },
    });
  }

  async findAllChats(hashedRoomId: string): Promise<DirectMessage[]> {
    return this.prisma.directMessage.findMany({
      where: { roomId: hashedRoomId },
      orderBy: { created_at: 'asc' },
    });
  }

  async findAllReceivedChats(userId: string): Promise<DirectMessage[]> {
    return this.prisma.directMessage.findMany({
      where: { recieverId: userId, seen: false },
      orderBy: { created_at: 'asc' },
    });
  }

  async updateChat(
    senderId: string,
    receiverId: string,
    updateChatDto: UpdateChatDto
  ): Promise<void> {
    const hasshedRoomName = await this.generateHashedRommId(senderId, receiverId);

    await this.prisma.directMessage.updateMany({
      where: {
        roomId: hasshedRoomName,
        recieverId: senderId,
        seen: false,
      },
      data: updateChatDto,
    });
  }
}
    

Chat Gateway — Direct Messages

The chat gateway operates on the /chatGateway namespace. When a user joins a room, the gateway hashes the sender+receiver IDs, loads message history, and manages Socket.io room subscriptions. Message sending includes blocked user checks and cross-namespace notifications.

@WebSocketGateway({
  namespace: 'chatGateway',
  cors: {
    origin: `${process.env.APP_URI}:5173/chat`,
  },
})
export class ChatGateway
  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
  constructor(
    private readonly chatService: ChatService,
    private readonly connectedClientsService: ConnectedClientsService,
    private readonly usersService: UsersService,
    private prisma: PrismaService,
    private appGateway: AppGateway,
  ) {}

  @WebSocketServer()
  server: Server;

  private logger: Logger = new Logger('CHAT Gateway Log');

  handleConnection(client: Socket): void {
    this.connectedClientsService.addClientInchat(client);
    this.logger.log(`Client connected: ${client.id}`);
  }

  @SubscribeMessage('joinRoom')
  async handleJoinRoom(
    @MessageBody() payload: { senderId: string; recieverId: string },
    @ConnectedSocket() socket: Socket,
  ): Promise<void> {
    const hasshedRoomName = await this.chatService.generateHashedRommId(
      payload.senderId,
      payload.recieverId,
    );
    const messages = await this.chatService.findAllChats(hasshedRoomName);

    // Bootstrap: create an empty message for first-time conversations
    if (messages.length === 0) {
      await this.prisma.directMessage.create({
        data: {
          content: '',
          senderId: payload.senderId,
          recieverId: payload.recieverId,
          roomId: hasshedRoomName,
          seen: true,
        },
      });
    }

    // Leave all previous rooms (except socket's own room)
    Array.from(socket.rooms)
      .filter((id) => id !== socket.id)
      .forEach((id) => socket.leave(id));

    // Join the hashed room
    if (!socket.rooms.has(hasshedRoomName)) {
      socket.join(hasshedRoomName);
      this.server.to(socket.id).emit('joined', { roomName: hasshedRoomName });
    }
  }

  @SubscribeMessage('message')
  async handleEvent(
    @MessageBody() payload: CreateChatDto,
    @ConnectedSocket() socket: Socket,
  ): Promise<void> {
    // Check if sender is blocked by receiver
    const blockedUser = await this.usersService.findOneBlockedUser(
      payload.recieverId,
      payload.senderId,
    );

    if (!blockedUser) {
      const hasshedRoomName = await this.chatService.generateHashedRommId(
        payload.senderId,
        payload.recieverId,
      );

      if (!socket.rooms.has(hasshedRoomName)) {
        socket.join(hasshedRoomName);
      }

      // Broadcast to room participants
      this.server.to(hasshedRoomName).emit('getMessage', {
        senderId: payload.senderId,
        receiverId: payload.recieverId,
        text: payload.content,
        room: hasshedRoomName,
      });

      // Persist message to database
      await this.chatService.createChat(payload);

      // Notify receiver in chat namespace (refresh their conversation list)
      for (const [key, val] of this.connectedClientsService.getAllClientsFromChat()) {
        if (val === payload.recieverId) {
          this.server.to(key).emit('refresh');
        }
      }

      // Cross-namespace notification via app gateway
      for (const [key, val] of this.connectedClientsService.getAllClients()) {
        if (val === payload.recieverId) {
          this.appGateway.server.to(key).emit('notifMessage', payload);
        }
      }
    }
  }

  handleDisconnect(client: Socket): void {
    this.connectedClientsService.removeClientFromChat(client);
    this.logger.log(`Client disconnected: ${client.id}`);
  }
}
    

Channel System — Group Communication

Channel Gateway

The channel gateway handles group chat with support for public channels, password-protected channels, and private (invite-only) channels. It manages the full lifecycle: creation, joining, messaging, role management, and deletion.

Channel Creation with Password Protection

@WebSocketGateway({
  namespace: 'channelGateway',
  cors: {
    origin: `${process.env.APP_URI}:5173/channels`,
  },
})
export class ChannelGateway
  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
  @WebSocketServer()
  server: Server;

  private connectedClientsInChannel: Map<string, string> = new Map();

  @SubscribeMessage('createChannel')
  async handleCreateChannel(
    @MessageBody() payload: CreateChannelDto,
    @ConnectedSocket() socket: Socket,
  ): Promise<void> {
    if (payload.channelPassword) {
      // Hash password with SHA-256 before storing
      const hachedChannelPswd = createHash('sha256')
        .update(payload.channelPassword)
        .digest('hex');

      const channelProtected = await this.prisma.channel.create({
        data: {
          channelName: payload.channelName,
          channelType: payload.channelType,
          channelPassword: hachedChannelPswd,
          channelOwnerId: payload.channelOwnerId,
        },
      });

      await this.channelService.createChannelOwner(
        channelProtected.channelOwnerId,
        channelProtected.id,
      );
      socket.join(channelProtected.id);
    } else {
      const channel = await this.channelService.createChannel(payload);
      await this.channelService.createChannelOwner(
        channel.channelOwnerId,
        channel.id,
      );
      socket.join(channel.id);
    }

    this.server.to(socket.id).emit('refrechCreateChannel');
  }
}
    

Channel Messaging

Once a member has joined a channel, sending messages is straightforward: ensure the socket is in the room, persist the message to the database, then broadcast to all members in the channel.

@SubscribeMessage('messageChannel')
async handleMessage(
  @MessageBody() payload: CreateChannelMessageDto,
  @ConnectedSocket() socket: Socket,
): Promise<void> {
  // Ensure the sender is in the channel room
  if (!socket.rooms.has(payload.channelId)) {
    socket.join(payload.channelId);
  }

  // Persist message to database
  await this.channelService.createChannelMessage(payload);

  // Broadcast to all channel members
  this.server.to(payload.channelId).emit('onMessage', payload);
}
    

Joining Channels with Access Control

Joining a channel involves multiple validation layers: checking existing membership, verifying kicked status, and for protected channels, validating the hashed password.

@SubscribeMessage('joinChannel')
async joinChannel(
  @MessageBody() payload: {
    userId: string;
    channelId: string;
    channelPasword: string;
  },
  @ConnectedSocket() socket: Socket,
): Promise<void> {
  const channel = await this.channelService.findOneChannel(payload.channelId);
  const member = await this.prisma.channelMember.findUnique({
    where: {
      userAndChannel: {
        userId: payload.userId,
        channelId: payload.channelId,
      },
    },
  });

  if (member) {
    // Existing member — verify password for PROTECTED channels
    if (channel.channelType === 'PROTECTED' && payload.channelPasword) {
      const hachedChannelPswd = createHash('sha256')
        .update(payload.channelPasword)
        .digest('hex');

      if (channel.channelPassword === hachedChannelPswd) {
        socket.join(channel.id);
        this.server.to(socket.id).emit('joinedSuccessfully');
      } else {
        this.server.to(socket.id).emit('error', 'Invalid password');
      }
    } else {
      socket.join(channel.id);
      this.server.to(socket.id).emit('joinedSuccessfully');
    }
  } else {
    // New member — check if kicked
    const kickedMember = await this.channelService.findOneKickedMember(
      payload.channelId,
      payload.userId,
    );

    if (!kickedMember) {
      const user = await this.usersService.findOne(payload.userId);
      await this.channelService.createChannelMember({
        userId: payload.userId,
        channelId: payload.channelId,
        role: 'MEMBER',
      });
      socket.join(payload.channelId);
      this.server.to(payload.channelId).emit('refrechMember');
    } else {
      this.server.to(socket.id).emit('error', 'You are kicked from this Channel');
    }
  }
}
    

Moderation System

The moderation system uses role-based permissions with time-based bans and mutes. A @Cron job runs every second to automatically unban or unmute members when their punishment expires — preserving their original role (MEMBER or ADMIN).

Role State Machine

Each channel member has a role that transitions based on moderation actions. The key insight is that MEMBER and ADMIN are treated as parallel tracks — a muted/banned admin returns to ADMIN, not MEMBER:

+--------------------------------------------------+
|              ROLE TRANSITIONS                    |
+--------------------------------------------------+
|                                                  |
|  MEMBER track:                                   |
|  +---------+    mute    +---------------+        |
|  | MEMBER  |----------->| MUTED_MEMBER  |        |
|  |         |<-----------|  (timed)      |        |
|  +---------+   unmute   +---------------+        |
|       |                                          |
|       |  ban            +---------------+        |
|       +---------------->| BANNED_MEMBER |        |
|       |<----------------|  (timed)      |        |
|       |    unban        +---------------+        |
|                                                  |
|  ADMIN track:                                    |
|  +---------+    mute    +---------------+        |
|  | ADMIN   |----------->| MUTED_ADMIN   |        |
|  |         |<-----------|  (timed)      |        |
|  +---------+   unmute   +---------------+        |
|       |                                          |
|       |  ban            +---------------+        |
|       +---------------->| BANNED_ADMIN  |        |
|       |<----------------|  (timed)      |        |
|       |    unban        +---------------+        |
|                                                  |
|  Cross-track:                                    |
|  MEMBER <--- promote/demote ---> ADMIN           |
|  OWNER (immutable — channel creator)             |
+--------------------------------------------------+

Timed Bans & Auto-Unban

// Ban a member — transitions MEMBER → BANNED_MEMBER or ADMIN → BANNED_ADMIN
async updateChannelMemberBannedTime(
  channelId: string,
  userId: string,
  bannedTime: string,
): Promise<ChannelMember> {
  const unbanneTime = new Date();
  const bannTime = new Date(bannedTime);

  if (bannTime.getMinutes() > unbanneTime.getMinutes()) {
    unbanneTime.setMinutes(
      unbanneTime.getMinutes()
        + (bannTime.getMinutes() - unbanneTime.getMinutes()),
    );
  }

  const status = await this.findOneChannelMemberStatus(channelId, userId);

  if (status === 'MEMBER') {
    return this.prisma.channelMember.update({
      where: { userAndChannel: { userId, channelId } },
      data: { role: 'BANNED_MEMBER', bannedTime, unbanneTime },
    });
  } else if (status === 'ADMIN') {
    return this.prisma.channelMember.update({
      where: { userAndChannel: { userId, channelId } },
      data: { role: 'BANNED_ADMIN', bannedTime, unbanneTime },
    });
  }
}

// Cron: auto-unban expired members → restores MEMBER role
@Cron(CronExpression.EVERY_SECOND)
async handleUnbanneMember(): Promise<{ count: number }> {
  const currentDate = new Date();
  return this.prisma.channelMember.updateMany({
    where: {
      role: 'BANNED_MEMBER',
      unbanneTime: { lte: currentDate },
    },
    data: { role: 'MEMBER', bannedTime: null, unbanneTime: null },
  });
}

// Cron: auto-unban expired admins → restores ADMIN role
@Cron(CronExpression.EVERY_SECOND)
async handleUnbanneAdmin(): Promise<{ count: number }> {
  const currentDate = new Date();
  return this.prisma.channelMember.updateMany({
    where: {
      role: 'BANNED_ADMIN',
      unbanneTime: { lte: currentDate },
    },
    data: { role: 'ADMIN', bannedTime: null, unbanneTime: null },
  });
}
    

Timed Mutes & Auto-Unmute

Muting follows the same pattern as banning — the member's role transitions to MUTED_MEMBER or MUTED_ADMIN, and a cron job restores the original role when the mute expires.

// Mute a member — transitions MEMBER → MUTED_MEMBER or ADMIN → MUTED_ADMIN
async updateChannelMemberMutedTime(
  channelId: string,
  userId: string,
  mutedTime: string,
): Promise<ChannelMember> {
  const unmuteTime = new Date();
  const muteTime = new Date(mutedTime);

  if (muteTime.getMinutes() > unmuteTime.getMinutes()) {
    unmuteTime.setMinutes(
      unmuteTime.getMinutes()
        + (muteTime.getMinutes() - unmuteTime.getMinutes()),
    );
  }

  const status = await this.findOneChannelMemberStatus(channelId, userId);

  if (status === 'MEMBER') {
    return this.prisma.channelMember.update({
      where: { userAndChannel: { userId, channelId } },
      data: { role: 'MUTED_MEMBER', mutedTime, unmuteTime },
    });
  } else if (status === 'ADMIN') {
    return this.prisma.channelMember.update({
      where: { userAndChannel: { userId, channelId } },
      data: { role: 'MUTED_ADMIN', mutedTime, unmuteTime },
    });
  }
}

// Cron: auto-unmute expired members → restores MEMBER role
@Cron(CronExpression.EVERY_SECOND)
async handleUnmuteMember(): Promise<{ count: number }> {
  const currentDate = new Date();
  return this.prisma.channelMember.updateMany({
    where: {
      role: 'MUTED_MEMBER',
      unmuteTime: { lte: currentDate },
    },
    data: { role: 'MEMBER', mutedTime: null, unmuteTime: null },
  });
}

// Cron: auto-unmute expired admins → restores ADMIN role
@Cron(CronExpression.EVERY_SECOND)
async handleUnmuteAdmin(): Promise<{ count: number }> {
  const currentDate = new Date();
  return this.prisma.channelMember.updateMany({
    where: {
      role: 'MUTED_ADMIN',
      unmuteTime: { lte: currentDate },
    },
    data: { role: 'ADMIN', mutedTime: null, unmuteTime: null },
  });
}
    

Kick Members with Cross-Namespace Redirect

@SubscribeMessage('kickMember')
async handleKickMember(
  @MessageBody() payload: CreateKickedMemberDto,
  @ConnectedSocket() socket: Socket,
): Promise<void> {
  const member = await this.channelService.findOneChannelMember(
    payload.channelId,
    payload.userId,
  );

  if (member && (member.role === 'MEMBER' || member.role === 'ADMIN')) {
    const channel = await this.channelService.findOneChannel(payload.channelId);
    const user = await this.usersService.findOne(payload.userId);

    // Record the kick — prevents rejoin
    await this.channelService.createKickedMember(payload);

    // Remove from channel membership
    await this.channelService.removeChannelMember(
      payload.channelId,
      payload.userId,
    );

    // Notify the channel
    this.server
      .to(payload.channelId)
      .emit('onMessage', `${user.name} is kicked from channel: ${channel.channelName}`);
    this.server.to(payload.channelId).emit('refrechMember');

    // Force-redirect the kicked user via their socket
    for (const [key, val] of this.connectedClientsInChannel) {
      if (val === payload.userId) {
        this.server.to(key).emit('redirectAfterGetKicked');
      }
    }
  }
}
    

Blocked User Filtering in Channel Messages

async findAllChannelNonBlockedMessages(
  channelId: string,
  senderId: string,
): Promise<ChannelMessage[]> {
  // Fetch the user's block list
  const user = await this.prisma.user.findUnique({
    where: { id: senderId },
    include: { userThatBlock: {} },
  });

  const blockedUserIds = user.userThatBlock.map(
    (blocked) => blocked.blockedUserId,
  );

  // Return messages excluding blocked users
  return this.prisma.channelMessage.findMany({
    where: {
      channelId: channelId,
      userId: { notIn: blockedUserIds },
    },
    orderBy: { created_at: 'asc' },
  });
}
    

Conclusion

Building a production-ready chat system demands careful separation of concerns. The dual-layer architecture (DMs + Channels) with isolated Socket.io namespaces scales naturally, while the role-based moderation system with timed punishments provides the control needed for community management.

Key takeaways:

• Deterministic room IDs — SHA-256 hashed user ID pairs eliminate duplicate conversations without any lookup
• Namespace isolation — Separate gateways for DMs, channels, and social features keep concerns clean
• Cross-namespace notifications — Inject gateways to send alerts across Socket.io namespaces
• Role state machine — MEMBER ↔ MUTED/BANNED transitions preserve privileges after expiration
• Cron-based moderation — Automatic unban/unmute with original role restoration
• Server-side filtering — Blocked user messages filtered at the query level, not on the client

This architecture powers real-time communication for a multiplayer game platform, handling concurrent users across direct messages, group channels, and game invitations simultaneously.