fast init

src/template_project/adapters/access_token/cryptographer.py

@@ -0,0 +1,29 @@
+from typing import override
+from uuid import UUID
+
+from cryptography.fernet import Fernet
+
+from template_project.application.access_token.cryptographer import AccessTokenCryptographer
+from template_project.application.access_token.entity import AccessTokenId
+
+
+type RawAccessToken = str
+
+
+class FernetAccessTokenCryptographer(AccessTokenCryptographer):
+    def __init__(self, fernet: Fernet) -> None:
+        self._fernet = fernet
+
+    @override
+    def crypto(self, access_token_id: AccessTokenId) -> RawAccessToken:
+        return self._fernet.encrypt(
+            str(access_token_id).encode("utf-8"),
+        ).decode("utf-8")
+
+    @override
+    def decrypto(self, raw_access_token: RawAccessToken) -> AccessTokenId:
+        return AccessTokenId(
+            UUID(
+                self._fernet.decrypt(raw_access_token).decode("utf-8"),
+            ),
+        )

src/template_project/adapters/access_token/factory.py

@@ -0,0 +1,17 @@
+from typing import override
+from template_project.application.access_token.entity import AccessToken
+from template_project.application.access_token.entity_factory import AccessTokenFactory
+from template_project.application.user.entity import UserId
+from template_project.web_api.configuration import AccessTokenConfiguration
+
+
+class DefaultAccessTokenFactory(AccessTokenFactory):
+    def __init__(self, configuration: AccessTokenConfiguration) -> None:
+        self._configuration = configuration
+
+    @override
+    def execute(self, user_id: UserId) -> AccessToken:
+        return AccessToken.factory(
+            user_id=user_id,
+            expires_in=self._configuration.expires_in,
+        )

src/template_project/adapters/data_gateways/access_token.py

@@ -0,0 +1,20 @@
+from typing import override
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from template_project.adapters.data_gateways.tables import access_token_table
+from template_project.application.access_token.data_gateway import AccessTokenDataGateway
+from template_project.application.access_token.entity import AccessToken, AccessTokenId
+
+
+class DefaultAccessTokenDataGateway(AccessTokenDataGateway):
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    @override
+    async def load_with_id(self, access_token_id: AccessTokenId) -> AccessToken | None:
+        statement = select(AccessToken).where(
+            access_token_table.c.id==access_token_id,
+        )
+        result = await self._session.execute(statement)
+        return result.scalar_one_or_none()

src/template_project/adapters/data_gateways/tables.py

@@ -0,0 +1,40 @@
+__all__ = (
+    "meta_data",
+    "user_table",
+    "access_token_table",
+)
+
+from sqlalchemy import UUID, Boolean, Column, DateTime, ForeignKey, MetaData, String, Table
+from sqlalchemy.orm import registry
+
+from template_project.application.access_token.entity import AccessToken
+from template_project.application.user.entity import User
+
+
+meta_data = MetaData()
+
+user_table = Table(
+    "users",
+    meta_data,
+    Column("id", UUID, primary_key=True),
+    Column("email", String, unique=True, nullable=False),
+    Column("hashed_password", String, nullable=False),
+    Column("deleted_at", DateTime(timezone=True)),
+    Column("created_at", DateTime(timezone=True), nullable=False),
+)
+
+access_token_table = Table(
+    "access_token",
+    meta_data,
+    Column("id", UUID, primary_key=True),
+    Column("user_id", UUID, ForeignKey("users.id", ondelete="CASCADE"), nullable=False),
+    Column("revoked", Boolean, nullable=False),
+    Column("expires_in", DateTime(timezone=True), nullable=False),
+    Column("deleted_at", DateTime(timezone=True)),
+    Column("created_at", DateTime(timezone=True), nullable=False),
+)
+
+mapper_registry = registry()
+
+mapper_registry.map_imperatively(User, user_table)
+mapper_registry.map_imperatively(AccessToken, access_token_table)

src/template_project/adapters/data_gateways/user.py

@@ -0,0 +1,27 @@
+from typing import override
+from sqlalchemy import exists, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from template_project.adapters.data_gateways.tables import user_table
+from template_project.application.user.data_gateway import UserDataGateway
+from template_project.application.user.entity import User, UserId
+
+
+class DefaultUserDataGateway(UserDataGateway):
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    @override
+    async def load_with_id(self, id_: UserId) -> User | None:
+        statement = select(User).where(user_table.c.id==id_)
+        result = await self._session.execute(statement)
+        return result.scalar_one_or_none()
+
+    @override
+    async def exists_by_email(self, email: str) -> bool:
+        statement = select(exists(select(user_table).where(user_table.c.email == email)))
+        result = await self._session.execute(statement)
+        result_fetchone = result.fetchone()
+        if result_fetchone is None:
+            return False
+        return result_fetchone[0]

src/template_project/adapters/password_utils.py

@@ -0,0 +1,40 @@
+from abc import abstractmethod
+from typing import override
+
+import argon2
+from argon2.exceptions import Argon2Error
+
+from template_project.application.common.containers import SecretString
+from template_project.application.user.password_utils import PasswordHasher, PasswordVerifying
+
+
+class ArgonPasswordHasher(PasswordHasher):
+    def __init__(
+        self,
+        password_hasher: argon2.PasswordHasher,
+    ) -> None:
+        self._password_hasher = password_hasher
+
+    @override
+    def hash(self, password: SecretString) -> str:
+        return self._password_hasher.hash(password.get_value())
+
+
+class ArgonPasswordVerifying(PasswordVerifying):
+    def __init__(
+        self,
+        password_hasher: argon2.PasswordHasher,
+    ) -> None:
+        self._password_hasher = password_hasher
+
+    @abstractmethod
+    def verify(
+        self,
+        verifiable_password: SecretString,
+        hashed_password: str,
+    ) -> bool:
+        try:
+            return self._password_hasher.verify(hashed_password, verifiable_password.get_value())
+        except Argon2Error as e:
+            return False
+

src/template_project/adapters/unit_of_work.py

@@ -0,0 +1,18 @@
+from typing import Any, override
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from template_project.application.common.unit_of_work import UnitOfWork
+
+
+class DefaultUnitOfWork(UnitOfWork):
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    @override
+    def add(self, *entities: Any) -> None:
+        self._session.add_all(entities)
+
+    @override
+    async def commit(self) -> None:
+        await self._session.commit()