perf: redis everywhere

apps/server/Dockerfile

@@ -14,9 +14,9 @@ FROM node:20.12.0-alpine3.19 AS runner
 
 WORKDIR /app
 
-COPY --from=builder /build/dist/ ./dist/
 COPY package*.json ./
 RUN npm install --omit=dev
+COPY --from=builder /build/dist/ ./dist/
 
 EXPOSE 3000
 

apps/server/src/controller/player.controller.ts

@@ -60,7 +60,7 @@ export class PlayerController {
           this.playerService
             .getScoreboard(
               game.id,
-              game.game.actions.map((a) => a.key),
+              game.game.actions.map((a: any) => a.key),
             )
             .then((score) => {
               socket.emit('scoreboard', score)

apps/server/src/models/client.model.ts

@@ -1,6 +1,7 @@
 import { DataTypes, Filterable, Model, WhereOptions } from 'sequelize'
 import { ClientAttributes, ClientInput } from '$/interface/client.interface'
 import { sequelizeConnection } from '$/utils/database'
+import { RedisClientType, RedisDefaultModules, RedisFunctions, RedisScripts } from 'redis'
 
 export class Client
   extends Model<ClientAttributes, ClientInput>

apps/server/src/models/game.model.ts

@@ -2,6 +2,8 @@ import { DataTypes, Model, col, fn } from 'sequelize'
 import { GameAttributes, GameInput } from '$/interface/game.interface'
 import { sequelizeConnection } from '$/utils/database'
 import { GameHistory } from './history.model'
+import { RedisClientType, RedisDefaultModules, RedisFunctions, RedisScripts } from 'redis'
+import { createLogger } from '$/utils/logger'
 
 export class Game
   extends Model<GameAttributes, GameInput>
@@ -57,7 +59,19 @@ Game.init(
   { timestamps: true, sequelize: sequelizeConnection, paranoid: true },
 )
 
+const LAST_ACTIVE_CACHE_KEY = "db::last_active"
+
 export class GameRepository {
+  logger = createLogger('GameRepository')
+
+  constructor(
+    private readonly redis: RedisClientType<
+      RedisDefaultModules,
+      RedisFunctions,
+      RedisScripts
+    >,
+  ) {}
+
   async getAllGames(): Promise<Game[]> {
     return Game.findAll()
   }
@@ -67,6 +81,16 @@ export class GameRepository {
   }
 
   async getLastActiveGame() {
+    const cache = await this.redis.get(LAST_ACTIVE_CACHE_KEY)
+    if (cache) {
+      try {
+        const game = JSON.parse(cache)
+        return game
+      } catch (e) {
+        this.logger.warn(`last active cache is not JSON ${cache}`)
+        await this.redis.del(LAST_ACTIVE_CACHE_KEY)
+      }
+    }
     const game = await Game.findOne({
       order: [['updatedAt', 'DESC']],
       attributes: ['id', 'open', 'actions'],
@@ -76,10 +100,12 @@ export class GameRepository {
       game: res,
       status: res?.open ? 'playing' : 'waiting',
     }))
+    await this.redis.set(LAST_ACTIVE_CACHE_KEY, JSON.stringify(game))
     return game
   }
 
   async createGame(game: Game) {
+    await this.redis.set(`game_key::${game.id}`, game.actions.map(x => x.key).join(','))
     return Game.create(game)
   }
 
@@ -96,6 +122,7 @@ export class GameRepository {
   }
 
   async startGame(game_id: string) {
+    await this.redis.del(LAST_ACTIVE_CACHE_KEY)
     return Game.findOne({ where: { open: true } }).then(async (game) => {
       await game?.update({ open: false })
       return Game.update(
@@ -111,6 +138,7 @@ export class GameRepository {
   }
 
   async endGame(id: string) {
+    await this.redis.del(LAST_ACTIVE_CACHE_KEY)
     return Game.update({ open: false }, { where: { id } }).then(() => {
       const keys = Game.findOne({
         where: { id },

apps/server/src/models/history.model.ts

@@ -67,17 +67,33 @@ export class GameHistoryRepository {
     key: string,
     vote: number,
   ) {
+    const allKeys = await this.redis.get(`game_key::${game_id}`)
     const total = await this.redis.incrBy(`game::${game_id}::${key}`, vote)
-    this.redis.keys(`game::${game_id}::*`).then(async (keys) => {
-      keys.forEach(async (k) => {
-        if (k !== `game::${game_id}::${key}`) {
+    if (!allKeys) {
+      this.redis.keys(`game::${game_id}::*`).then(async (keys) => {
+        const allKeys: string[] = []
+        keys.forEach(async (k) => {
+          const thisKey = k.split("::")[2]
+          allKeys.push(thisKey)
+          if (thisKey != key) {
+            const kTotal = parseInt((await this.redis.get(k)) || '0')
+            const decrease = Math.floor((Math.abs(total - kTotal) * vote) / 100)
+            const remain = kTotal - decrease
+            if (remain > 0) this.redis.decrBy(k, decrease)
+          }
+        })
+        await this.redis.set(`game_key::${game_id}`, allKeys.join(","))
+      })
+    } else {
+      allKeys.split(",").forEach(async k => {
+        if (k != key) {
           const kTotal = parseInt((await this.redis.get(k)) || '0')
           const decrease = Math.floor((Math.abs(total - kTotal) * vote) / 100)
           const remain = kTotal - decrease
           if (remain > 0) this.redis.decrBy(k, decrease)
         }
       })
-    })
+    }
   }
 
   async getHistoryByPlayerID(game_id: string, player_id: string) {

apps/server/src/server.ts

@@ -46,7 +46,7 @@ export async function initServer(app: Express, server: HTTPServer) {
     })
   sequelizeConnection.sync({ force: process.env.FORCE_DB_SYNC === 'true' })
 
-  const gameRepository = new GameRepository()
+  const gameRepository = new GameRepository(pubClient)
   const clientRepository = new ClientRepository()
   const gameHistoryRepository = new GameHistoryRepository(pubClient)