Files
mtusi2026lab2-fork/app/repositories/postgres.py
T

161 lines
6.8 KiB
Python

import uuid
import asyncpg
from app.core.errors import ApiError
from app.core.security import new_token
from app.repositories.memory import (
ChatRow, MessageRow, UserRow, iso_z,
)
def _user(row: asyncpg.Record | None) -> UserRow | None:
if row is None:
return None
return UserRow(
id=str(row['id']), username=row['username'], display_name=row['display_name'],
password_hash=row['password_hash'], created_at=iso_z(row['created_at']),
)
def _chat(row: asyncpg.Record) -> ChatRow:
moment = row['created_at']
return ChatRow(
id=str(row['id']), title=row['title'], member_ids=[str(x) for x in row['member_ids']],
created_dt=moment, created_at=iso_z(moment),
)
def _message(row: asyncpg.Record) -> MessageRow:
moment = row['created_at']
return MessageRow(
id=str(row['id']), chat_id=str(row['chat_id']), sender_id=str(row['sender_id']),
text=row['text'], created_dt=moment, created_at=iso_z(moment),
)
class PgStorage:
"""Хранилище пользователей, сессий, чатов, участников и сообщений на PostgreSQL."""
def __init__(self, pool: asyncpg.Pool, session_store):
self.pool = pool
self.session_store = session_store
async def ready(self) -> bool:
try:
async with self.pool.acquire() as connection:
database_ready = await connection.fetchval('SELECT 1') == 1
return database_ready and await self.session_store.ready()
except (asyncpg.PostgresError, OSError, TimeoutError):
return False
async def create_user(self, username: str, display_name: str, password_hash: str) -> UserRow:
try:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'INSERT INTO users (id, username, display_name, password_hash) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), username, display_name, password_hash,
)
except asyncpg.UniqueViolationError as exc:
if exc.constraint_name == 'users_username_key':
raise ApiError(409, 'Username is already taken') from None
raise
return _user(row)
async def user_by_username(self, username: str) -> UserRow | None:
async with self.pool.acquire() as connection:
return _user(await connection.fetchrow(
'SELECT * FROM users WHERE username = $1', username
))
async def user(self, user_id: str) -> UserRow | None:
async with self.pool.acquire() as connection:
return _user(await connection.fetchrow(
'SELECT * FROM users WHERE id = $1', uuid.UUID(user_id)
))
async def create_session(self, user_id: str, ttl_seconds: int):
return await self.session_store.create_session(user_id, ttl_seconds)
async def session(self, token: str):
return await self.session_store.session(token)
async def revoke(self, token: str) -> bool:
return await self.session_store.revoke(token)
async def create_chat(self, title: str, member_ids: list[str], caller_id: str) -> ChatRow:
if caller_id not in member_ids:
raise ApiError(400, 'Creator must be included in member_ids')
chat_id = uuid.uuid4()
try:
async with self.pool.acquire() as connection:
async with connection.transaction():
created_at = await connection.fetchval(
'INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at',
chat_id, title,
)
await connection.executemany(
'INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)',
[(chat_id, uuid.UUID(member_id)) for member_id in member_ids],
)
except asyncpg.ForeignKeyViolationError:
raise ApiError(400, 'Unknown member id') from None
return ChatRow(
id=str(chat_id), title=title, member_ids=list(member_ids),
created_dt=created_at, created_at=iso_z(created_at),
)
async def chat(self, chat_id: str) -> ChatRow | None:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'SELECT c.id, c.title, c.created_at, '
'array_agg(cm.user_id ORDER BY cm.user_id) AS member_ids '
'FROM chats c JOIN chat_members cm ON cm.chat_id = c.id '
'WHERE c.id = $1 GROUP BY c.id', uuid.UUID(chat_id),
)
return _chat(row) if row else None
async def chats_of(self, user_id: str) -> list[ChatRow]:
async with self.pool.acquire() as connection:
rows = await connection.fetch(
'SELECT c.id, c.title, c.created_at, '
'array_agg(cm_all.user_id ORDER BY cm_all.user_id) AS member_ids '
'FROM chats c '
'JOIN chat_members mine ON mine.chat_id = c.id '
'JOIN chat_members cm_all ON cm_all.chat_id = c.id '
'WHERE mine.user_id = $1 '
'GROUP BY c.id ORDER BY c.created_at, c.id', uuid.UUID(user_id),
)
return [_chat(row) for row in rows]
async def add_message(self, chat_id: str, sender_id: str, text: str) -> MessageRow:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'INSERT INTO messages (id, chat_id, sender_id, text) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), uuid.UUID(chat_id), uuid.UUID(sender_id), text,
)
return _message(row)
async def messages_page(self, chat_id: str, cursor_key, limit: int):
"""Прочитать одну отсортированную keyset-страницу и одну строку для проверки продолжения."""
chat_uuid = uuid.UUID(chat_id)
async with self.pool.acquire() as connection:
if cursor_key is None:
rows = await connection.fetch(
'SELECT * FROM messages WHERE chat_id = $1 '
'ORDER BY created_at, id LIMIT $2', chat_uuid, limit + 1,
)
else:
created_at, id_value = cursor_key
rows = await connection.fetch(
'SELECT * FROM messages WHERE chat_id = $1 '
'AND (created_at, id) > ($2, $3) '
'ORDER BY created_at, id LIMIT $4',
chat_uuid, created_at, uuid.UUID(int=id_value), limit + 1,
)
has_more = len(rows) > limit
return [_message(row) for row in rows[:limit]], has_more