fix(application): use ports for serializable transactions (#62)

Author: emptybutton

src/ttt/application/stars_purchase/dto/__init__.py renamed to src/ttt/application/common/errors/__init__.py

@@ -0,0 +1 @@
+class SerializationError(Exception): ...

src/ttt/application/common/errors/serialization_error.py

@@ -23,4 +23,5 @@ async def __call__(
         """
         :raises ttt.application.common.ports.map.NotUniqueUserIdError:
         :raises ttt.application.common.ports.map.NotUniqueActiveInvitationToGameUserIdsError:
+        :raises ttt.application.common.errors.serialization_error.SerializationError:
         """  # noqa: E501

src/ttt/application/common/ports/map.py

@@ -1,5 +1,33 @@
+from abc import ABC, abstractmethod
 from contextlib import AbstractAsyncContextManager
+from types import TracebackType
 from typing import Any
 
 
-Transaction = AbstractAsyncContextManager[Any]
+class SerializableTransaction(AbstractAsyncContextManager[Any], ABC):
+    @abstractmethod
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        """
+        :raises ttt.application.common.errors.serialization_error.SerializationError:
+        """  # noqa: E501
+
+        return None
+
+    @abstractmethod
+    async def commit(self) -> None:
+        """
+        :raises ttt.application.common.errors.serialization_error.SerializationError:
+        """  # noqa: E501
+
+
+class NotSerializableTransaction(AbstractAsyncContextManager[Any], ABC):
+    @abstractmethod
+    async def commit(self) -> None: ...
+
+
+class ReadonlyTransaction(AbstractAsyncContextManager[Any], ABC): ...

src/ttt/application/common/ports/transaction.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from ttt.application.common.ports.map import Map
-from ttt.application.common.ports.transaction import Transaction
+from ttt.application.common.ports.transaction import SerializableTransaction
 from ttt.application.common.ports.uuids import UUIDs
 from ttt.application.game.game.ports.game_log import GameLog
 from ttt.application.game.game.ports.game_views import GameViews
@@ -16,29 +16,38 @@ class CancelGame:
     games: Games
     game_views: GameViews
     uuids: UUIDs
-    transaction: Transaction
+    transaction: SerializableTransaction
     log: GameLog
 
     async def __call__(self, user_id: int) -> None:
+        """
+        :raises ttt.application.common.errors.serialization_error.SerializationError:
+        """  # noqa: E501
+
         async with self.transaction:
             game = await self.games.current_user_game(user_id)
 
             if game is None:
-                await self.game_views.no_game_view(user_id)
+                await self.log.no_current_game_to_cancel_game(user_id)
+                await self.transaction.commit()
+                await self.game_views.no_current_game_view(user_id)
                 return
 
             try:
                 tracking = Tracking()
                 game.cancel(user_id, tracking)
             except AlreadyCompletedGameError:
                 await self.log.already_completed_game_to_cancel(game, user_id)
+                await self.transaction.commit()
                 await self.game_views.game_already_complteted_view(
                     user_id,
                     game,
                 )
                 return
+            else:
+                await self.log.game_cancelled(user_id, game)
 
-            await self.log.game_cancelled(user_id, game)
+                await self.map_(tracking)
+                await self.transaction.commit()
 
-            await self.map_(tracking)
-            await self.game_views.game_view(game)
+                await self.game_views.game_view(game)

src/ttt/application/game/game/cancel_game.py

@@ -0,0 +1,79 @@
+from asyncio import gather
+from dataclasses import dataclass
+from uuid import UUID
+
+from ttt.application.common.ports.map import Map
+from ttt.application.common.ports.randoms import Randoms
+from ttt.application.common.ports.transaction import SerializableTransaction
+from ttt.application.common.ports.uuids import UUIDs
+from ttt.application.game.game.ports.game_ai_gateway import GameAiGateway
+from ttt.application.game.game.ports.game_dao import GameDao
+from ttt.application.game.game.ports.game_log import GameLog
+from ttt.application.game.game.ports.game_views import GameViews
+from ttt.application.game.game.ports.games import Games
+from ttt.application.user.common.ports.users import Users
+from ttt.entities.core.game.game import (
+    AlreadyCompletedGameError,
+    NotAiCurrentMoveError,
+)
+from ttt.entities.tools.tracking import Tracking
+
+
+@dataclass(frozen=True, unsafe_hash=False)
+class MakeAiMoveInGame:
+    map_: Map
+    games: Games
+    game_views: GameViews
+    users: Users
+    uuids: UUIDs
+    randoms: Randoms
+    ai_gateway: GameAiGateway
+    transaction: SerializableTransaction
+    log: GameLog
+    dao: GameDao
+
+    async def __call__(self, game_id: UUID, ai_id: UUID) -> None:
+        """
+        :raises ttt.application.common.errors.serialization_error.SerializationError:
+        """  # noqa: E501
+
+        async with self.transaction:
+            game = await self.games.game_with_id(game_id)
+
+            if game is None:
+                await self.log.no_game_to_make_ai_move(game_id)
+                return
+
+            (
+                free_cell_random,
+                ai_move_cell_number_int,
+            ) = await gather(
+                self.randoms.random(),
+                self.ai_gateway.next_move_cell_number_int(game, ai_id),
+            )
+            try:
+                tracking = Tracking()
+                ai_move = game.make_ai_move(
+                    ai_id,
+                    ai_move_cell_number_int,
+                    free_cell_random,
+                    tracking,
+                )
+            except AlreadyCompletedGameError:
+                await self.log.already_completed_game_to_make_ai_move(
+                    game, ai_id,
+                )
+            except NotAiCurrentMoveError:
+                await self.log.not_ai_current_move_to_make_ai_move(
+                    game, ai_id,
+                )
+            else:
+                await self.log.ai_move_maked(game, ai_move, ai_id)
+
+                if game.is_completed():
+                    await self.log.game_was_completed_by_ai(ai_id, game)
+
+                await self.map_(tracking)
+                await self.transaction.commit()
+
+                await self.game_views.game_view(game)

src/ttt/application/game/game/make_ai_move_in_game.py

@@ -3,11 +3,12 @@
 
 from ttt.application.common.ports.map import Map
 from ttt.application.common.ports.randoms import Randoms
-from ttt.application.common.ports.transaction import Transaction
+from ttt.application.common.ports.transaction import SerializableTransaction
 from ttt.application.common.ports.uuids import UUIDs
 from ttt.application.game.game.ports.game_ai_gateway import GameAiGateway
 from ttt.application.game.game.ports.game_dao import GameDao
 from ttt.application.game.game.ports.game_log import GameLog
+from ttt.application.game.game.ports.game_tasks import GameTasks
 from ttt.application.game.game.ports.game_views import GameViews
 from ttt.application.game.game.ports.games import Games
 from ttt.application.user.common.ports.users import Users
@@ -29,20 +30,25 @@ class MakeMoveInGame:
     uuids: UUIDs
     randoms: Randoms
     ai_gateway: GameAiGateway
-    transaction: Transaction
+    transaction: SerializableTransaction
     log: GameLog
     dao: GameDao
+    tasks: GameTasks
 
     async def __call__(
         self,
         user_id: int,
         cell_number_int: int,
     ) -> None:
+        """
+        :raises ttt.application.common.errors.serialization_error.SerializationError:
+        """  # noqa: E501
+
         async with self.transaction:
             game = await self.games.current_user_game(user_id)
 
             if game is None:
-                await self.game_views.no_game_view(user_id)
+                await self.game_views.no_current_game_view(user_id)
                 return
 
             (
@@ -68,6 +74,7 @@ async def __call__(
                     user_id,
                     cell_number_int,
                 )
+                await self.transaction.commit()
                 await self.game_views.game_already_complteted_view(
                     user_id,
                     game,
@@ -78,6 +85,7 @@ async def __call__(
                     user_id,
                     cell_number_int,
                 )
+                await self.transaction.commit()
                 await self.game_views.not_current_user_view(
                     user_id,
                     game,
@@ -88,48 +96,31 @@ async def __call__(
                     user_id,
                     cell_number_int,
                 )
+                await self.transaction.commit()
                 await self.game_views.no_cell_view(user_id, game)
             except AlreadyFilledCellError:
                 await self.log.already_filled_cell_to_make_move(
                     game,
                     user_id,
                     cell_number_int,
                 )
+                await self.transaction.commit()
                 await self.game_views.already_filled_cell_error(
                     user_id,
                     game,
                 )
             else:
                 await self.log.user_move_maked(user_id, game, user_move)
 
-                if user_move.next_move_ai_id is not None:
-                    await self.game_views.game_view(game)
+                if game.is_completed():
+                    await self.log.game_was_completed_by_user(user_id, game)
 
-                    (
-                        free_cell_random,
-                        ai_move_cell_number_int,
-                    ) = await gather(
-                        self.randoms.random(),
-                        self.ai_gateway.next_move_cell_number_int(
-                            game,
-                            user_move.next_move_ai_id,
-                        ),
-                    )
-                    ai_move = game.make_ai_move(
-                        user_move.next_move_ai_id,
-                        ai_move_cell_number_int,
-                        free_cell_random,
-                        tracking,
-                    )
+                await self.map_(tracking)
 
-                    await self.log.ai_move_maked(
-                        user_id,
-                        game,
-                        ai_move,
+                if user_move.next_move_ai_id is not None:
+                    await self.tasks.make_ai_move(
+                        game.id, user_move.next_move_ai_id,
                     )
 
-                if game.is_completed():
-                    await self.log.game_completed(user_id, game)
-
-                await self.map_(tracking)
+                await self.transaction.commit()
                 await self.game_views.game_view(game)

src/ttt/application/game/game/make_move_in_game.py

@@ -1,11 +1,40 @@
 from abc import ABC, abstractmethod
+from uuid import UUID
 
 from ttt.entities.core.game.game import Game
 from ttt.entities.core.game.move import AiMove, UserMove
 from ttt.entities.core.user.user import User
 
 
 class GameLog(ABC):
+    @abstractmethod
+    async def no_current_game_to_make_move(
+        self,
+        user_id: int,
+        /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def no_current_game_to_cancel_game(
+        self,
+        user_id: int,
+        /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def no_game_to_make_ai_move(
+        self,
+        game_id: UUID,
+        /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def no_current_game(
+        self,
+        user_id: int,
+        /,
+    ) -> None: ...
+
     @abstractmethod
     async def game_against_ai_started(
         self,
@@ -33,20 +62,28 @@ async def user_move_maked(
     @abstractmethod
     async def ai_move_maked(
         self,
-        user_id: int,
         game: Game,
         move: AiMove,
+        ai_id: UUID,
         /,
     ) -> None: ...
 
     @abstractmethod
-    async def game_completed(
+    async def game_was_completed_by_user(
         self,
         user_id: int,
         game: Game,
         /,
     ) -> None: ...
 
+    @abstractmethod
+    async def game_was_completed_by_ai(
+        self,
+        ai_id: UUID,
+        game: Game,
+        /,
+    ) -> None: ...
+
     @abstractmethod
     async def user_already_in_game_to_start_game_against_ai(
         self, user: User, /,
@@ -96,3 +133,19 @@ async def already_completed_game_to_cancel(
         user_id: int,
         /,
     ) -> None: ...
+
+    @abstractmethod
+    async def already_completed_game_to_make_ai_move(
+        self,
+        game: Game,
+        ai_id: UUID,
+        /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def not_ai_current_move_to_make_ai_move(
+        self,
+        game: Game,
+        ai_id: UUID,
+        /,
+    ) -> None: ...

src/ttt/application/game/game/ports/game_log.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from uuid import UUID
+
+
+class GameTasks(ABC):
+    @abstractmethod
+    async def make_ai_move(
+        self,
+        game_id: UUID,
+        ai_id: UUID,
+        /,
+    ) -> None: ...