Fix ranked match result synchronization

Author: Dieg0Code

src/api/modules/gameplay/repository.py

@@ -208,11 +208,15 @@ async def get_user_by_id(self, user_id: UUID) -> User | None:
         return await self.session.get(User, user_id)
 
     async def create_move(self, move: GameMove) -> GameMove:
-        self.session.add(move)
+        await self.create_move_uncommitted(move)
         await self.session.commit()
         await self.session.refresh(move)
         return move
 
+    async def create_move_uncommitted(self, move: GameMove) -> GameMove:
+        self.session.add(move)
+        return move
+
     async def rollback(self) -> None:
         await self.session.rollback()
 
@@ -237,11 +241,18 @@ async def list_moves(self, game_id: UUID, limit: int = 200) -> list[GameMove]:
         return list(result.scalars().all())
 
     async def save_game(self, game: Game) -> Game:
-        self.session.add(game)
+        await self.save_game_uncommitted(game)
         await self.session.commit()
         await self.session.refresh(game)
         return game
 
+    async def save_game_uncommitted(self, game: Game) -> Game:
+        self.session.add(game)
+        return game
+
+    async def commit(self) -> None:
+        await self.session.commit()
+
     async def delete_game(self, game_id: UUID) -> bool:
         exists_stmt = (
             select(func.count())

src/api/modules/gameplay/service.py

@@ -307,8 +307,15 @@ async def record_inference_move(
             action_idx=inference.action_idx,
             value=inference.value,
         )
-        stored_move = await self.game_repository.create_move(move)
-        await self._update_game_state(game=game, board_after=scratch)
+        stored_move = await self.game_repository.create_move_uncommitted(move)
+        should_apply_rated_result = await self._update_game_state(
+            game=game,
+            board_after=scratch,
+            commit=False,
+        )
+        await self.game_repository.commit()
+        if should_apply_rated_result:
+            await self._apply_rated_result(game)
         return stored_move, game
 
     async def list_game_moves(self, game_id: UUID, limit: int = 200) -> list[GameMove]:
@@ -349,7 +356,7 @@ async def record_manual_move(
 
         r1, c1, r2, c2 = move
         try:
-            stored_move = await self.game_repository.create_move(
+            stored_move = await self.game_repository.create_move_uncommitted(
                 GameMove(
                     game_id=game_id,
                     ply=ply,
@@ -365,26 +372,42 @@ async def record_manual_move(
                     value=0.0,
                 )
             )
+            should_apply_rated_result = await self._update_game_state(
+                game=game,
+                board_after=scratch,
+                commit=False,
+            )
+            await self.game_repository.commit()
         except DBAPIError as exc:
             await self.game_repository.rollback()
             if _is_concurrent_move_db_error(exc):
                 raise MoveConflictError(
                     "Concurrent move conflict; refresh board and retry."
                 ) from exc
             raise
-        await self._update_game_state(game=game, board_after=scratch)
+        if should_apply_rated_result:
+            await self._apply_rated_result(game)
         return stored_move, game
 
-    async def _update_game_state(self, game: Game, board_after: AtaxxBoard) -> None:
+    async def _update_game_state(
+        self,
+        game: Game,
+        board_after: AtaxxBoard,
+        *,
+        commit: bool = True,
+    ) -> bool:
         changed = False
         if game.started_at is None:
             game.started_at = datetime.now(timezone.utc).replace(tzinfo=None)
             changed = True
 
         if not board_after.is_game_over():
             if changed:
-                await self.game_repository.save_game(game)
-            return
+                if commit:
+                    await self.game_repository.save_game(game)
+                else:
+                    await self.game_repository.save_game_uncommitted(game)
+            return False
 
         result = board_after.get_result()
         if result == 1:
@@ -400,28 +423,38 @@ async def _update_game_state(self, game: Game, board_after: AtaxxBoard) -> None:
         game.status = GameStatus.FINISHED
         game.termination_reason = TerminationReason.NORMAL
         game.ended_at = datetime.now(timezone.utc).replace(tzinfo=None)
-        await self.game_repository.save_game(game)
+        if commit:
+            await self.game_repository.save_game(game)
+        else:
+            await self.game_repository.save_game_uncommitted(game)
+        return self._should_apply_rated_result(game)
 
-        if (
+    def _should_apply_rated_result(self, game: Game) -> bool:
+        return (
             game.rated
             and game.season_id is not None
             and game.player1_id is not None
             and game.player2_id is not None
             and game.winner_side is not None
             and self.ranking_service is not None
-        ):
-            await self.ranking_service.apply_rated_result(
-                game_id=game.id,
-                season_id=game.season_id,
-                player1_id=game.player1_id,
-                player2_id=game.player2_id,
-                winner_side=game.winner_side,
-            )
-            # Keep leaderboard_entry synchronized after each rated game result.
-            await self.ranking_service.recompute_leaderboard(
-                season_id=game.season_id,
-                limit=500,
-            )
+        )
 
+    async def _apply_rated_result(self, game: Game) -> None:
+        if self.ranking_service is None:
+            raise RuntimeError("Ranking service is required for rated result finalization.")
+        if game.season_id is None or game.player1_id is None or game.player2_id is None or game.winner_side is None:
+            raise RuntimeError("Rated game is missing required identifiers for rating application.")
+        await self.ranking_service.apply_rated_result(
+            game_id=game.id,
+            season_id=game.season_id,
+            player1_id=game.player1_id,
+            player2_id=game.player2_id,
+            winner_side=game.winner_side,
+        )
+        # Keep leaderboard_entry synchronized after each rated game result.
+        await self.ranking_service.recompute_leaderboard(
+            season_id=game.season_id,
+            limit=500,
+        )
 
 

src/api/modules/matches/repository.py

@@ -35,21 +35,32 @@ async def get_bot_profile(self, user_id: UUID) -> BotProfile | None:
         return result.scalars().first()
 
     async def save_game(self, game: Game) -> Game:
-        self.session.add(game)
+        await self.save_game_uncommitted(game)
         await self.session.commit()
         await self.session.refresh(game)
         return game
 
+    async def save_game_uncommitted(self, game: Game) -> Game:
+        self.session.add(game)
+        return game
+
     async def create_move(self, move: GameMove) -> GameMove:
-        self.session.add(move)
+        await self.create_move_uncommitted(move)
         await self.session.commit()
         await self.session.refresh(move)
         return move
 
+    async def create_move_uncommitted(self, move: GameMove) -> GameMove:
+        self.session.add(move)
+        return move
+
     async def next_ply(self, game_id: UUID) -> int:
-        stmt = select(GameMove).where(GameMove.game_id == game_id)
+        stmt = select(func.count()).select_from(GameMove).where(GameMove.game_id == game_id)
         result = await self.session.execute(stmt)
-        return len(list(result.scalars().all()))
+        return int(result.scalar_one())
+
+    async def commit(self) -> None:
+        await self.session.commit()
 
     async def get_last_move(self, game_id: UUID) -> GameMove | None:
         stmt = (

src/api/modules/matches/service.py

@@ -273,7 +273,7 @@ async def submit_move(
         board_after = board_to_state(board)
 
         ply = await self.repository.next_ply(game_id)
-        stored = await self.repository.create_move(
+        stored = await self.repository.create_move_uncommitted(
             GameMove(
                 game_id=game_id,
                 ply=ply,
@@ -289,8 +289,14 @@ async def submit_move(
                 value=0.0,
             )
         )
-
-        await self._update_game_terminal_state(game=game, board=board)
+        should_apply_rated_result = await self._update_game_terminal_state(
+            game=game,
+            board=board,
+            commit=False,
+        )
+        await self.repository.commit()
+        if should_apply_rated_result:
+            await self._apply_rated_result(game)
         return stored
 
     async def advance_bot_turn(
@@ -368,7 +374,7 @@ async def advance_bot_turn(
         board_after = board_to_state(board)
         ply = await self.repository.next_ply(game_id)
 
-        stored = await self.repository.create_move(
+        stored = await self.repository.create_move_uncommitted(
             GameMove(
                 game_id=game_id,
                 ply=ply,
@@ -384,7 +390,14 @@ async def advance_bot_turn(
                 value=value,
             )
         )
-        await self._update_game_terminal_state(game=game, board=board)
+        should_apply_rated_result = await self._update_game_terminal_state(
+            game=game,
+            board=board,
+            commit=False,
+        )
+        await self.repository.commit()
+        if should_apply_rated_result:
+            await self._apply_rated_result(game)
         return stored
 
     @staticmethod
@@ -399,12 +412,21 @@ def _resolve_actor_side(game: Game, actor_user_id: UUID) -> PlayerSide:
             return PlayerSide.P2
         raise PermissionError("Authenticated user is not a participant in this match.")
 
-    async def _update_game_terminal_state(self, game: Game, board: AtaxxBoard) -> None:
+    async def _update_game_terminal_state(
+        self,
+        game: Game,
+        board: AtaxxBoard,
+        *,
+        commit: bool = True,
+    ) -> bool:
         if not board.is_game_over():
             if game.status != GameStatus.IN_PROGRESS:
                 game.status = GameStatus.IN_PROGRESS
-                await self.repository.save_game(game)
-            return
+                if commit:
+                    await self.repository.save_game(game)
+                else:
+                    await self.repository.save_game_uncommitted(game)
+            return False
 
         result = board.get_result()
         if result == 1:
@@ -420,28 +442,39 @@ async def _update_game_terminal_state(self, game: Game, board: AtaxxBoard) -> No
         game.status = GameStatus.FINISHED
         game.termination_reason = TerminationReason.NORMAL
         game.ended_at = datetime.now(timezone.utc).replace(tzinfo=None)
-        await self.repository.save_game(game)
+        if commit:
+            await self.repository.save_game(game)
+        else:
+            await self.repository.save_game_uncommitted(game)
+        return self._should_apply_rated_result(game)
 
-        if (
+    def _should_apply_rated_result(self, game: Game) -> bool:
+        return (
             game.rated
             and game.season_id is not None
             and game.player1_id is not None
             and game.player2_id is not None
             and game.winner_side is not None
             and self.ranking_service is not None
-        ):
-            await self.ranking_service.apply_rated_result(
-                game_id=game.id,
-                season_id=game.season_id,
-                player1_id=game.player1_id,
-                player2_id=game.player2_id,
-                winner_side=game.winner_side,
-            )
-            # Keep public leaderboard in sync with the latest rated result.
-            await self.ranking_service.recompute_leaderboard(
-                season_id=game.season_id,
-                limit=500,
-            )
+        )
+
+    async def _apply_rated_result(self, game: Game) -> None:
+        if self.ranking_service is None:
+            raise RuntimeError("Ranking service is required for rated result finalization.")
+        if game.season_id is None or game.player1_id is None or game.player2_id is None or game.winner_side is None:
+            raise RuntimeError("Rated game is missing required identifiers for rating application.")
+        await self.ranking_service.apply_rated_result(
+            game_id=game.id,
+            season_id=game.season_id,
+            player1_id=game.player1_id,
+            player2_id=game.player2_id,
+            winner_side=game.winner_side,
+        )
+        # Keep public leaderboard in sync with the latest rated result.
+        await self.ranking_service.recompute_leaderboard(
+            season_id=game.season_id,
+            limit=500,
+        )
 
     @staticmethod
     def _to_side(player: int) -> PlayerSide: