Refactor updatePlayTime worker with structured play time tracking

- Introduce type-safe data structures for play time tracking
- Replace string-based map keys with structured objects
- Improve type safety and readability of play time accumulation logic
- Simplify database update loops by using structured data

Author: needs

apps/worker/src/workers/updatePlayTime.ts

@@ -50,164 +50,199 @@ export async function updatePlayTime(snapshotId: number) {
   const deltaPlayTime = deltaSecond > 10 * 60 ? 5 * 60 : deltaSecond;
   const clients = removeDuplicatedClients(snapshot.clients);
 
-  // Create maps to store accumulated play times
-  const playerMapPlayTimes = new Map<string, number>();
-  const playerGameTypePlayTimes = new Map<string, number>();
-  const playerPlayTimes = new Map<string, number>();
-  const clanMapPlayTimes = new Map<string, number>();
-  const clanGameTypePlayTimes = new Map<string, number>();
-  const clanPlayTimes = new Map<string, number>();
-  const clanPlayerPlayTimes = new Map<string, number>();
+  // Create maps to store accumulated play times with structured values
+  type PlayerMapPlayTime = { playerName: string; mapId: number; playTime: number };
+  type PlayerGameTypePlayTime = { playerName: string; gameTypeName: string; playTime: number };
+  type PlayerPlayTime = { playerName: string; playTime: number };
+  type ClanMapPlayTime = { clanName: string; mapId: number; playTime: number };
+  type ClanGameTypePlayTime = { clanName: string; gameTypeName: string; playTime: number };
+  type ClanPlayTime = { clanName: string; playTime: number };
+  type ClanPlayerPlayTime = { clanName: string; playerName: string; playTime: number };
+
+  const playerMapPlayTimes = new Map<string, PlayerMapPlayTime>();
+  const playerGameTypePlayTimes = new Map<string, PlayerGameTypePlayTime>();
+  const playerPlayTimes = new Map<string, PlayerPlayTime>();
+  const clanMapPlayTimes = new Map<string, ClanMapPlayTime>();
+  const clanGameTypePlayTimes = new Map<string, ClanGameTypePlayTime>();
+  const clanPlayTimes = new Map<string, ClanPlayTime>();
+  const clanPlayerPlayTimes = new Map<string, ClanPlayerPlayTime>();
 
   // Process all clients and accumulate play times
   for (const client of clients) {
     // Player-Map play time
     const playerMapKey = `${client.playerName}_${snapshot.mapId}`;
-    playerMapPlayTimes.set(playerMapKey, (playerMapPlayTimes.get(playerMapKey) || 0) + deltaPlayTime);
+    const existingPlayerMapTime = playerMapPlayTimes.get(playerMapKey)?.playTime ?? 0;
+    playerMapPlayTimes.set(playerMapKey, {
+      playerName: client.playerName,
+      mapId: snapshot.mapId,
+      playTime: existingPlayerMapTime + deltaPlayTime
+    });
 
     // Player-GameType play time
     const playerGameTypeKey = `${client.playerName}_${snapshot.map.gameTypeName}`;
-    playerGameTypePlayTimes.set(playerGameTypeKey, (playerGameTypePlayTimes.get(playerGameTypeKey) || 0) + deltaPlayTime);
+    const existingPlayerGameTypeTime = playerGameTypePlayTimes.get(playerGameTypeKey)?.playTime ?? 0;
+    playerGameTypePlayTimes.set(playerGameTypeKey, {
+      playerName: client.playerName,
+      gameTypeName: snapshot.map.gameTypeName,
+      playTime: existingPlayerGameTypeTime + deltaPlayTime
+    });
 
     // Player total play time
-    playerPlayTimes.set(client.playerName, (playerPlayTimes.get(client.playerName) || 0) + deltaPlayTime);
+    const existingPlayerTime = playerPlayTimes.get(client.playerName)?.playTime ?? 0;
+    playerPlayTimes.set(client.playerName, {
+      playerName: client.playerName,
+      playTime: existingPlayerTime + deltaPlayTime
+    });
 
     if (client.clanName !== null) {
       // Clan-Map play time
       const clanMapKey = `${client.clanName}_${snapshot.mapId}`;
-      clanMapPlayTimes.set(clanMapKey, (clanMapPlayTimes.get(clanMapKey) || 0) + deltaPlayTime);
+      const existingClanMapTime = clanMapPlayTimes.get(clanMapKey)?.playTime ?? 0;
+      clanMapPlayTimes.set(clanMapKey, {
+        clanName: client.clanName,
+        mapId: snapshot.mapId,
+        playTime: existingClanMapTime + deltaPlayTime
+      });
 
       // Clan-GameType play time
       const clanGameTypeKey = `${client.clanName}_${snapshot.map.gameTypeName}`;
-      clanGameTypePlayTimes.set(clanGameTypeKey, (clanGameTypePlayTimes.get(clanGameTypeKey) || 0) + deltaPlayTime);
+      const existingClanGameTypeTime = clanGameTypePlayTimes.get(clanGameTypeKey)?.playTime ?? 0;
+      clanGameTypePlayTimes.set(clanGameTypeKey, {
+        clanName: client.clanName,
+        gameTypeName: snapshot.map.gameTypeName,
+        playTime: existingClanGameTypeTime + deltaPlayTime
+      });
 
       // Clan total play time
-      clanPlayTimes.set(client.clanName, (clanPlayTimes.get(client.clanName) || 0) + deltaPlayTime);
+      const existingClanTime = clanPlayTimes.get(client.clanName)?.playTime ?? 0;
+      clanPlayTimes.set(client.clanName, {
+        clanName: client.clanName,
+        playTime: existingClanTime + deltaPlayTime
+      });
 
       // Clan-Player play time
       const clanPlayerKey = `${client.clanName}_${client.playerName}`;
-      clanPlayerPlayTimes.set(clanPlayerKey, (clanPlayerPlayTimes.get(clanPlayerKey) || 0) + deltaPlayTime);
+      const existingClanPlayerTime = clanPlayerPlayTimes.get(clanPlayerKey)?.playTime ?? 0;
+      clanPlayerPlayTimes.set(clanPlayerKey, {
+        clanName: client.clanName,
+        playerName: client.playerName,
+        playTime: existingClanPlayerTime + deltaPlayTime
+      });
     }
   }
 
-  // Batch update database sequentially
   // Update PlayerInfoMap records
-  for (const [key, playTime] of playerMapPlayTimes.entries()) {
-    const [playerName, mapId] = key.split('_');
+  for (const data of playerMapPlayTimes.values()) {
     await prisma.playerInfoMap.upsert({
       where: {
         playerName_mapId: {
-          mapId: parseInt(mapId),
-          playerName,
+          mapId: data.mapId,
+          playerName: data.playerName,
         },
       },
       update: {
-        playTime: { increment: playTime },
+        playTime: { increment: data.playTime },
       },
       create: {
-        player: { connect: { name: playerName } },
-        map: { connect: { id: parseInt(mapId) } },
-        playTime,
+        player: { connect: { name: data.playerName } },
+        map: { connect: { id: data.mapId } },
+        playTime: data.playTime,
       },
     });
   }
 
   // Update PlayerInfoGameType records
-  for (const [key, playTime] of playerGameTypePlayTimes.entries()) {
-    const [playerName, gameTypeName] = key.split('_');
+  for (const data of playerGameTypePlayTimes.values()) {
     await prisma.playerInfoGameType.upsert({
       where: {
         playerName_gameTypeName: {
-          gameTypeName,
-          playerName,
+          gameTypeName: data.gameTypeName,
+          playerName: data.playerName,
         },
       },
       update: {
-        playTime: { increment: playTime },
+        playTime: { increment: data.playTime },
       },
       create: {
-        player: { connect: { name: playerName } },
-        gameType: { connect: { name: gameTypeName } },
-        playTime,
+        player: { connect: { name: data.playerName } },
+        gameType: { connect: { name: data.gameTypeName } },
+        playTime: data.playTime,
       },
     });
   }
 
   // Update Player records
-  for (const [playerName, playTime] of playerPlayTimes.entries()) {
+  for (const data of playerPlayTimes.values()) {
     await prisma.player.update({
-      where: { name: playerName },
-      data: { playTime: { increment: playTime } },
+      where: { name: data.playerName },
+      data: { playTime: { increment: data.playTime } },
     });
   }
 
   // Update ClanInfoMap records
-  for (const [key, playTime] of clanMapPlayTimes.entries()) {
-    const [clanName, mapId] = key.split('_');
+  for (const data of clanMapPlayTimes.values()) {
     await prisma.clanInfoMap.upsert({
       where: {
         clanName_mapId: {
-          mapId: parseInt(mapId),
-          clanName,
+          mapId: data.mapId,
+          clanName: data.clanName,
         },
       },
       update: {
-        playTime: { increment: playTime },
+        playTime: { increment: data.playTime },
       },
       create: {
-        clan: { connect: { name: clanName } },
-        map: { connect: { id: parseInt(mapId) } },
-        playTime,
+        clan: { connect: { name: data.clanName } },
+        map: { connect: { id: data.mapId } },
+        playTime: data.playTime,
       },
     });
   }
 
   // Update ClanInfoGameType records
-  for (const [key, playTime] of clanGameTypePlayTimes.entries()) {
-    const [clanName, gameTypeName] = key.split('_');
+  for (const data of clanGameTypePlayTimes.values()) {
     await prisma.clanInfoGameType.upsert({
       where: {
         clanName_gameTypeName: {
-          gameTypeName,
-          clanName,
+          gameTypeName: data.gameTypeName,
+          clanName: data.clanName,
         },
       },
       update: {
-        playTime: { increment: playTime },
+        playTime: { increment: data.playTime },
       },
       create: {
-        clan: { connect: { name: clanName } },
-        gameType: { connect: { name: gameTypeName } },
-        playTime,
+        clan: { connect: { name: data.clanName } },
+        gameType: { connect: { name: data.gameTypeName } },
+        playTime: data.playTime,
       },
     });
   }
 
   // Update Clan records
-  for (const [clanName, playTime] of clanPlayTimes.entries()) {
+  for (const data of clanPlayTimes.values()) {
     await prisma.clan.update({
-      where: { name: clanName },
-      data: { playTime: { increment: playTime } },
+      where: { name: data.clanName },
+      data: { playTime: { increment: data.playTime } },
     });
   }
 
   // Update ClanPlayerInfo records
-  for (const [key, playTime] of clanPlayerPlayTimes.entries()) {
-    const [clanName, playerName] = key.split('_');
+  for (const data of clanPlayerPlayTimes.values()) {
     await prisma.clanPlayerInfo.upsert({
       where: {
         clanName_playerName: {
-          clanName,
-          playerName,
+          clanName: data.clanName,
+          playerName: data.playerName,
         },
       },
       update: {
-        playTime: { increment: playTime },
+        playTime: { increment: data.playTime },
       },
       create: {
-        clan: { connect: { name: clanName } },
-        player: { connect: { name: playerName } },
-        playTime,
+        clan: { connect: { name: data.clanName } },
+        player: { connect: { name: data.playerName } },
+        playTime: data.playTime,
       },
     });
   }