Server-side Player controllers and services implementation

README.md

@@ -165,7 +165,7 @@ Fields:
 - [x] [Server-side Player model implementation](https://github.com/alan-hadyk/side-stacker-game/pull/6)
 - [x] [Server-side Game model implementation](https://github.com/alan-hadyk/side-stacker-game/pull/7)
 - [x] [Server-side Move model implementation](https://github.com/alan-hadyk/side-stacker-game/pull/8)
-- [ ] Server-side Player controllers and services implementation
+- [x] [Server-side Player controllers and services implementation](https://github.com/alan-hadyk/side-stacker-game/pull/9)
 - [ ] Server-side Game controllers and services implementation
 - [ ] Server-side Move controllers and services implementation
 - [ ] Server routes implementation

server/package.json

@@ -6,12 +6,17 @@
   "description": "Server for Side-Stacker game",
   "dependencies": {
     "express": "^4.18.2",
+    "lodash": "^4.17.21",
     "slonik": "^34.0.1",
+    "socket.io": "^4.7.1",
+    "uuid": "^9.0.0",
     "zod": "^3.21.4"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
+    "@types/lodash": "^4.14.195",
     "@types/node": "^20.4.2",
+    "@types/uuid": "^9.0.2",
     "@typescript-eslint/eslint-plugin": "^6.1.0",
     "@typescript-eslint/parser": "^6.1.0",
     "eslint": "^8.45.0",

server/src/clients/@types/websocketsServer.ts

@@ -0,0 +1,12 @@
+export interface ServerToClientEvents {
+  invalidateQuery: (queryKeys: {
+    entity: string[]
+    id?: string | number
+  }) => void
+}
+
+export interface ClientToServerEvents {}
+
+export interface InterServerEvents {}
+
+export interface SocketData {}

server/src/clients/websocketsServer.ts

@@ -0,0 +1,35 @@
+import {
+  ClientToServerEvents,
+  ServerToClientEvents,
+  InterServerEvents,
+  SocketData,
+} from "@app/clients/@types/websocketsServer"
+import { IncomingMessage, Server, ServerResponse } from "http"
+import { Server as SocketIOServer } from "socket.io"
+
+let websocketsServer: SocketIOServer<
+  ClientToServerEvents,
+  ServerToClientEvents,
+  InterServerEvents,
+  SocketData
+>
+
+export const createWebsocketsServer = (
+  httpServer: Server<typeof IncomingMessage, typeof ServerResponse>,
+) => {
+  websocketsServer = new SocketIOServer<
+    ClientToServerEvents,
+    ServerToClientEvents,
+    InterServerEvents,
+    SocketData
+  >(httpServer, {
+    connectionStateRecovery: {
+      // the backup duration of the sessions and the packets
+      maxDisconnectionDuration: 10 * 60 * 1000,
+      // whether to skip middlewares upon successful recovery
+      skipMiddlewares: true,
+    },
+  })
+}
+
+export { websocketsServer }

server/src/config/app.ts

@@ -1,4 +1,6 @@
 export const appConfig = {
-  host: "127.0.0.1",
-  port: 3000,
+  httpServer: {
+    host: "127.0.0.1",
+    port: 3000,
+  },
 }

server/src/features/games/@types/gameModel.ts

@@ -2,10 +2,20 @@ import { OrderDirection } from "@app/features/@types/models"
 import { Game, GameStateEnum } from "@app/features/games/@types/gameObject"
 
 export interface GameModelGetAll {
-  filters?: Record<
-    keyof Pick<Game, "current_player_id" | "current_game_state">,
-    string | GameStateEnum
+  filters?: Partial<
+    Record<
+      keyof Pick<
+        Game,
+        | "player1_id"
+        | "player2_id"
+        | "current_player_id"
+        | "current_game_state"
+        | "winner_id"
+      >,
+      string | GameStateEnum
+    >
   >
+  filterType?: "AND" | "OR"
   limit?: number
   offset?: number
   orderBy?: keyof Game

server/src/features/games/gameModel.ts

@@ -60,6 +60,7 @@ export class GameModel {
 
   static getAll = ({
     filters,
+    filterType = "AND",
     limit = 40,
     offset = 0,
     orderBy = "created_at",
@@ -80,7 +81,10 @@ export class GameModel {
       const query = sql.typeAlias("game")`
         SELECT * 
         FROM games 
-        WHERE ${sql.join(filtersFragments, sql.unsafe`, `)}
+        WHERE ${sql.join(
+          filtersFragments,
+          filterType === "AND" ? sql.unsafe`, ` : sql.unsafe` OR `,
+        )}
         ORDER BY ${sql.identifier([orderBy])} ${sql.unsafe([direction])} 
         LIMIT ${limit} 
         OFFSET ${offset}

server/src/features/players/playerController.ts

@@ -0,0 +1,228 @@
+import { websocketsServer } from "@app/clients/websocketsServer"
+import { PlayerModelGetAll } from "@app/features/players/@types/playerModel"
+import { PlayerModel } from "@app/features/players/playerModel"
+import { PlayerObject } from "@app/features/players/playerObject"
+import { convertObjectToObjectWithIsoDates } from "@app/helpers/objects/convertObjectToObjectWithIsoDates"
+import { GameService } from "@app/services/gameService"
+import { RequestValidationService } from "@app/services/requestValidationService"
+import { Request, Response, NextFunction } from "express"
+import { v4 as uuidv4 } from "uuid"
+
+export class PlayerController {
+  static create = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      RequestValidationService.validateQuery(req.query, [], [], [])
+      const { username } = RequestValidationService.validateBody(
+        req.body,
+        PlayerObject.pick({ username: true }),
+      )
+
+      const session_id = uuidv4()
+
+      const newPlayer = await PlayerModel.create({
+        session_id,
+        username,
+      })
+
+      const newPlayerWithIsoDates = {
+        ...newPlayer,
+        ...convertObjectToObjectWithIsoDates(newPlayer, [
+          "created_at",
+          "deleted_at",
+          "last_active_at",
+        ]),
+      }
+
+      // Emit an event to all connected clients to invalidate the players query
+      websocketsServer.emit("invalidateQuery", {
+        entity: ["players", "list"],
+      })
+
+      res.json(newPlayerWithIsoDates)
+    } catch (error) {
+      next(error)
+    }
+  }
+
+  static delete = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      RequestValidationService.validateQuery(req.query, [], [], [])
+      const { session_id } = RequestValidationService.validateBody(
+        req.body,
+        PlayerObject.omit({
+          created_at: true,
+          deleted_at: true,
+          last_active_at: true,
+          player_id: true,
+          username: true,
+        }),
+      )
+      const { player_id } = RequestValidationService.validateParams(
+        req.params,
+        PlayerObject.pick({ player_id: true }),
+      )
+
+      const deletedPlayer = await PlayerModel.delete(player_id, session_id)
+
+      const deletedPlayerWithIsoDates = {
+        ...deletedPlayer,
+        ...convertObjectToObjectWithIsoDates(deletedPlayer, [
+          "created_at",
+          "deleted_at",
+          "last_active_at",
+        ]),
+      }
+
+      await GameService.removeDeletedPlayerFromGames(deletedPlayer)
+
+      // Emit an event to all connected clients to invalidate the players query
+      websocketsServer.emit("invalidateQuery", {
+        entity: ["players", "list"],
+      })
+      websocketsServer.emit("invalidateQuery", {
+        entity: ["players", "detail"],
+        id: deletedPlayer.player_id,
+      })
+
+      res.json(deletedPlayerWithIsoDates)
+    } catch (error) {
+      next(error)
+    }
+  }
+
+  static getAll = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const { limit, offset, orderBy, orderDirection } =
+        RequestValidationService.validateQuery(
+          req.query,
+          ["limit", "offset", "orderDirection", "orderBy"],
+          [
+            "username",
+            "created_at",
+            "deleted_at",
+            "last_active_at",
+            "player_id",
+          ],
+          [],
+        )
+      RequestValidationService.validateBody(
+        req.body,
+        PlayerObject.omit({
+          created_at: true,
+          deleted_at: true,
+          last_active_at: true,
+          player_id: true,
+          session_id: true,
+          username: true,
+        }),
+      )
+
+      const players = await PlayerModel.getAll({
+        limit,
+        offset,
+        orderBy: orderBy as PlayerModelGetAll["orderBy"],
+        orderDirection,
+      })
+
+      const playersWithIsoDates = players.map((player) => {
+        const { created_at, deleted_at, last_active_at, player_id, username } =
+          player
+
+        return {
+          player_id,
+          username,
+          ...convertObjectToObjectWithIsoDates(
+            { created_at, deleted_at, last_active_at },
+            ["created_at", "deleted_at", "last_active_at"],
+          ),
+        }
+      })
+
+      res.json(playersWithIsoDates)
+    } catch (error) {
+      next(error)
+    }
+  }
+
+  static getById = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      RequestValidationService.validateQuery(req.query, [], [], [])
+      RequestValidationService.validateBody(
+        req.body,
+        PlayerObject.omit({
+          created_at: true,
+          deleted_at: true,
+          last_active_at: true,
+          player_id: true,
+          session_id: true,
+          username: true,
+        }),
+      )
+      const params = RequestValidationService.validateParams(
+        req.params,
+        PlayerObject.pick({ player_id: true }),
+      )
+
+      const player = await PlayerModel.getById(params.player_id)
+      const { created_at, deleted_at, last_active_at, player_id, username } =
+        player
+
+      const playerWithIsoDates = {
+        player_id,
+        username,
+        ...convertObjectToObjectWithIsoDates(
+          { created_at, deleted_at, last_active_at },
+          ["created_at", "deleted_at", "last_active_at"],
+        ),
+      }
+
+      res.json(playerWithIsoDates)
+    } catch (error) {
+      next(error)
+    }
+  }
+
+  static update = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      RequestValidationService.validateQuery(req.query, [], [], [])
+      const body = RequestValidationService.validateBody(
+        req.body,
+        PlayerObject.pick({
+          username: true,
+        }),
+      )
+      const params = RequestValidationService.validateParams(
+        req.params,
+        PlayerObject.pick({ player_id: true }),
+      )
+
+      const player = await PlayerModel.update(params.player_id, {
+        username: body.username,
+      })
+      const { created_at, deleted_at, last_active_at, player_id, username } =
+        player
+
+      const playerWithIsoDates = {
+        player_id,
+        username,
+        ...convertObjectToObjectWithIsoDates(
+          { created_at, deleted_at, last_active_at },
+          ["created_at", "deleted_at", "last_active_at"],
+        ),
+      }
+
+      // Emit an event to all connected clients to invalidate the players query
+      websocketsServer.emit("invalidateQuery", {
+        entity: ["players", "list"],
+      })
+      websocketsServer.emit("invalidateQuery", {
+        entity: ["players", "detail"],
+        id: player_id,
+      })
+
+      res.json(playerWithIsoDates)
+    } catch (error) {
+      next(error)
+    }
+  }
+}