185 lines
5.7 KiB
Python
185 lines
5.7 KiB
Python
from datetime import datetime
|
|
from uuid import UUID
|
|
|
|
from sqlalchemy import (
|
|
CheckConstraint,
|
|
DateTime,
|
|
ForeignKey,
|
|
Index,
|
|
LargeBinary,
|
|
UniqueConstraint,
|
|
delete,
|
|
literal,
|
|
select,
|
|
)
|
|
from sqlalchemy.dialects.postgresql import insert
|
|
from sqlalchemy.orm import Mapped, mapped_column
|
|
|
|
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 (
|
|
Base,
|
|
Database,
|
|
DatabaseSession,
|
|
PostgresUnitOfWork,
|
|
)
|
|
|
|
|
|
class UserRow(Base):
|
|
__tablename__ = "users"
|
|
__table_args__ = (
|
|
UniqueConstraint("username", name="users_username_key"),
|
|
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name="users_username_format"),
|
|
CheckConstraint(
|
|
"char_length(display_name) BETWEEN 1 AND 100", name="users_display_name_check"
|
|
),
|
|
CheckConstraint("password_hash LIKE '$argon2id$%'", name="users_password_hash_check"),
|
|
)
|
|
|
|
id: Mapped[UUID] = mapped_column(primary_key=True)
|
|
username: Mapped[str]
|
|
display_name: Mapped[str]
|
|
password_hash: Mapped[str]
|
|
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
|
|
|
|
|
class SessionRow(Base):
|
|
__tablename__ = "sessions"
|
|
__table_args__ = (
|
|
CheckConstraint("octet_length(token_hash) = 32", name="sessions_token_hash_check"),
|
|
CheckConstraint("expires_at > created_at", name="sessions_check"),
|
|
Index("sessions_user_idx", "user_id"),
|
|
)
|
|
|
|
token_hash: Mapped[bytes] = mapped_column(LargeBinary, primary_key=True)
|
|
user_id: Mapped[UUID] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"))
|
|
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
|
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
|
|
|
|
|
def user_of(row: UserRow | 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__ = ("_session",)
|
|
|
|
def __init__(self, session: DatabaseSession) -> None:
|
|
self._session = session
|
|
|
|
async def add(self, user: User) -> None:
|
|
statement = (
|
|
insert(UserRow)
|
|
.values(
|
|
id=user.id,
|
|
username=user.username.value,
|
|
display_name=user.display_name.value,
|
|
password_hash=user.password_hash,
|
|
created_at=user.created_at,
|
|
)
|
|
.on_conflict_do_nothing(index_elements=["username"])
|
|
.returning(literal(True))
|
|
)
|
|
inserted = (await self._session.execute(statement)).scalar_one_or_none()
|
|
if inserted is None:
|
|
raise UsernameAlreadyTaken("username уже занят")
|
|
|
|
|
|
class PostgresSessionRepository:
|
|
__slots__ = ("_session",)
|
|
|
|
def __init__(self, session: DatabaseSession) -> None:
|
|
self._session = session
|
|
|
|
async def add(self, session: Session) -> None:
|
|
expired = (
|
|
delete(SessionRow)
|
|
.where(
|
|
SessionRow.user_id == session.user_id, SessionRow.expires_at <= session.created_at
|
|
)
|
|
.cte("expired")
|
|
)
|
|
await self._session.execute(
|
|
insert(SessionRow)
|
|
.values(
|
|
token_hash=session.token_hash,
|
|
user_id=session.user_id,
|
|
created_at=session.created_at,
|
|
expires_at=session.expires_at,
|
|
)
|
|
.add_cte(expired)
|
|
)
|
|
|
|
async def remove(self, token_hash: bytes) -> None:
|
|
await self._session.execute(delete(SessionRow).where(SessionRow.token_hash == token_hash))
|
|
|
|
|
|
class PostgresIdentityUnitOfWork(PostgresUnitOfWork):
|
|
__slots__ = ()
|
|
|
|
@property
|
|
def users(self) -> PostgresUserRepository:
|
|
return PostgresUserRepository(self.session)
|
|
|
|
@property
|
|
def sessions(self) -> PostgresSessionRepository:
|
|
return PostgresSessionRepository(self.session)
|
|
|
|
|
|
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.session() as session:
|
|
row = (
|
|
await session.execute(select(UserRow).where(UserRow.id == user_id))
|
|
).scalar_one_or_none()
|
|
return user_of(row)
|
|
|
|
async def find_by_username(self, username: str) -> User | None:
|
|
async with self._database.session() as session:
|
|
row = (
|
|
await session.execute(select(UserRow).where(UserRow.username == username))
|
|
).scalar_one_or_none()
|
|
return user_of(row)
|
|
|
|
|
|
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.session() as session:
|
|
row = (
|
|
await session.execute(
|
|
select(SessionRow)
|
|
.where(
|
|
SessionRow.token_hash == token_hash,
|
|
SessionRow.expires_at > now,
|
|
)
|
|
.with_for_update(read=True, key_share=True)
|
|
)
|
|
).scalar_one_or_none()
|
|
if row is None:
|
|
return None
|
|
return Session(
|
|
token_hash=row.token_hash,
|
|
user_id=row.user_id,
|
|
created_at=row.created_at,
|
|
expires_at=row.expires_at,
|
|
)
|