import base64 import hashlib import re import secrets from datetime import timedelta from uuid import UUID, uuid4 from src.cursor import decode_cursor, encode_cursor from src.domain import Chat, Message, Record, User, order_key, utcnow from src.errors import DomainError, invalid, not_found from src.password import Passwords from src.repository import PostgresRepository def page(*, rows: list[Record], limit: int, scope: str) -> dict: items = rows[:limit] cursor = ( encode_cursor(scope=scope, key=order_key(items[-1])) if len(rows) > limit else None ) return {"items": items, "next_cursor": cursor} def unauthorized(*, basic=False): challenge = ( 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"' ) return DomainError( 401, "unauthorized", "Authentication required", {"WWW-Authenticate": challenge}, ) def bearer(value): if not value: raise unauthorized() scheme, _, token = value.partition(" ") if scheme.lower() != "bearer" or not re.fullmatch( r"[A-Za-z0-9_-]{32,256}", token ): raise unauthorized() return token def token_digest(value): return hashlib.sha256(value.encode()).digest() class MessengerService: def __init__( self, *, repository: PostgresRepository, passwords: Passwords, session_ttl: int, ) -> None: self.repository = repository self.passwords = passwords self.session_ttl = session_ttl def identify(self, *, value: str | None) -> User: token = bearer(value) user_id = self.repository.session_user(digest=token_digest(token)) user = self.repository.get_user(user_id=user_id) if user_id else None if user is None: raise unauthorized() return user def register( self, *, username: str, display_name: str, password: str ) -> User: encoded = self.passwords.hash(password=password) return self.repository.add_user( user=User(uuid4(), username, display_name, utcnow()), password_hash=encoded, ) def login(self, *, authorization: str | None): try: scheme, _, encoded = (authorization or "").partition(" ") if scheme.lower() != "basic": raise ValueError plain = base64.b64decode(encoded, validate=True).decode("utf-8") username, separator, password = plain.partition(":") if ( not separator or not re.fullmatch(r"[a-z0-9_]{3,32}", username) or not 12 <= len(password) <= 128 or not password.strip() ): raise ValueError except ValueError, UnicodeError: raise unauthorized(basic=True) from None user, password_hash = self.repository.credentials(username=username) if not self.passwords.verify(password=password, encoded=password_hash): raise unauthorized(basic=True) now = utcnow() expires = now + timedelta(seconds=self.session_ttl) token = secrets.token_urlsafe(32) self.repository.add_session( digest=token_digest(token), user_id=user.id, created_at=now, expires_at=expires, ) return { "token": token, "token_type": "Bearer", "expires_at": expires, "user": user, } def logout(self, *, authorization: str | None): self.identify(value=authorization) self.repository.delete_session( digest=token_digest(bearer(authorization)) ) def create_chat( self, *, actor_id: UUID, title: str, member_ids: list[UUID] ) -> Chat: return self.repository.add_chat( chat=Chat(uuid4(), title, tuple(member_ids), utcnow()), actor_id=actor_id, ) def get_chat(self, *, actor_id: UUID, chat_id: UUID) -> Chat: return self.repository.get_chat(actor_id=actor_id, chat_id=chat_id) def send( self, *, actor_id: UUID, chat_id: UUID, text: str, idempotency_key: str | None, ) -> Message: if not idempotency_key or not re.fullmatch( r"[A-Za-z0-9._:-]{1,128}", idempotency_key ): raise invalid() return self.repository.add_message( message=Message(uuid4(), chat_id, actor_id, text, utcnow()), idempotency_key=idempotency_key, ) def chats(self, *, actor_id: UUID, limit: int, cursor: str | None) -> dict: scope = f"chats:{actor_id}" after = decode_cursor(value=cursor, scope=scope) rows = self.repository.list_chats( actor_id=actor_id, after=after, limit=limit ) return page(rows=rows, limit=limit, scope=scope) def history( self, *, actor_id: UUID, chat: Chat, limit: int, cursor: str | None ) -> dict: if actor_id not in chat.member_ids: raise not_found() chat_id = chat.id scope = f"messages:{chat_id}" after = decode_cursor(value=cursor, scope=scope) rows = self.repository.list_messages( actor_id=actor_id, chat_id=chat_id, after=after, limit=limit ) return page(rows=rows, limit=limit, scope=scope)