Bring the application, own tests, Dockerfile, toolchain, compose stack, HAProxy and k6 configuration, migrations, hooks, evidence and level 4 scripts and the CI job from the lab 3 solution commit 61c0c28, merge the lab 3 Makefile targets into the lab 4 skeleton Makefile without touching its targets, and append the lab 3 solution variables to the skeleton .env.example. The package and the application follow the contract version 1.4.0, and the image and the throwaway test containers are tagged lab4 so they do not collide with a lab 3 stand on the same host. This is the starting point of the lab 4 cycle: lint, own tests and the offline skeleton check pass before any lab 4 change. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
125 lines
3.8 KiB
Python
125 lines
3.8 KiB
Python
from datetime import datetime
|
|
from uuid import UUID
|
|
|
|
from asyncpg import Record
|
|
|
|
from messenger.identity.domain.errors import UsernameAlreadyTaken
|
|
from messenger.identity.domain.models import Session, User
|
|
from messenger.identity.domain.values import DisplayName, Username
|
|
from messenger.shared.infrastructure.postgres import Connection, Database, PostgresUnitOfWork
|
|
|
|
INSERT_USER = """
|
|
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
ON CONFLICT (username) DO NOTHING
|
|
RETURNING true
|
|
"""
|
|
USER_BY_ID = """
|
|
SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1
|
|
"""
|
|
USER_BY_USERNAME = """
|
|
SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1
|
|
"""
|
|
INSERT_SESSION = """
|
|
WITH expired AS (DELETE FROM sessions WHERE user_id = $2 AND expires_at <= $3)
|
|
INSERT INTO sessions (token_hash, user_id, created_at, expires_at) VALUES ($1, $2, $3, $4)
|
|
"""
|
|
DELETE_SESSION = "DELETE FROM sessions WHERE token_hash = $1"
|
|
ACTIVE_SESSION = """
|
|
SELECT token_hash, user_id, created_at, expires_at
|
|
FROM sessions
|
|
WHERE token_hash = $1 AND expires_at > $2
|
|
"""
|
|
|
|
|
|
def user_of(row: Record | None) -> User | None:
|
|
if row is None:
|
|
return None
|
|
return User(
|
|
id=row["id"],
|
|
username=Username(row["username"]),
|
|
display_name=DisplayName(row["display_name"]),
|
|
created_at=row["created_at"],
|
|
password_hash=row["password_hash"],
|
|
)
|
|
|
|
|
|
class PostgresUserRepository:
|
|
__slots__ = ("_connection",)
|
|
|
|
def __init__(self, connection: Connection) -> None:
|
|
self._connection = connection
|
|
|
|
async def add(self, user: User) -> None:
|
|
inserted = await self._connection.fetchval(
|
|
INSERT_USER,
|
|
user.id,
|
|
user.username.value,
|
|
user.display_name.value,
|
|
user.password_hash,
|
|
user.created_at,
|
|
)
|
|
if inserted is None:
|
|
raise UsernameAlreadyTaken("username уже занят")
|
|
|
|
|
|
class PostgresSessionRepository:
|
|
__slots__ = ("_connection",)
|
|
|
|
def __init__(self, connection: Connection) -> None:
|
|
self._connection = connection
|
|
|
|
async def add(self, session: Session) -> None:
|
|
await self._connection.execute(
|
|
INSERT_SESSION,
|
|
session.token_hash,
|
|
session.user_id,
|
|
session.created_at,
|
|
session.expires_at,
|
|
)
|
|
|
|
async def remove(self, token_hash: bytes) -> None:
|
|
await self._connection.execute(DELETE_SESSION, token_hash)
|
|
|
|
|
|
class PostgresIdentityUnitOfWork(PostgresUnitOfWork):
|
|
__slots__ = ()
|
|
|
|
@property
|
|
def users(self) -> PostgresUserRepository:
|
|
return PostgresUserRepository(self.connection)
|
|
|
|
@property
|
|
def sessions(self) -> PostgresSessionRepository:
|
|
return PostgresSessionRepository(self.connection)
|
|
|
|
|
|
class PostgresUserDirectory:
|
|
__slots__ = ("_database",)
|
|
|
|
def __init__(self, database: Database) -> None:
|
|
self._database = database
|
|
|
|
async def find(self, user_id: UUID) -> User | None:
|
|
async with self._database.connection() as connection:
|
|
return user_of(await connection.fetchrow(USER_BY_ID, user_id))
|
|
|
|
async def find_by_username(self, username: str) -> User | None:
|
|
async with self._database.connection() as connection:
|
|
return user_of(await connection.fetchrow(USER_BY_USERNAME, username))
|
|
|
|
|
|
class PostgresSessionDirectory:
|
|
__slots__ = ("_database",)
|
|
|
|
def __init__(self, database: Database) -> None:
|
|
self._database = database
|
|
|
|
async def find(self, token_hash: bytes, now: datetime) -> Session | None:
|
|
async with self._database.connection() as connection:
|
|
row = await connection.fetchrow(ACTIVE_SESSION, token_hash, now)
|
|
return None if row is None else Session(**dict(row))
|
|
|
|
async def invalidate(self, session: Session) -> None:
|
|
return None
|