Complete lab

This commit is contained in:
2026-10-09 16:11:06 +03:00
parent d9fe67a8ce
commit 5de73c5475
48 changed files with 1749 additions and 203 deletions
+68
View File
@@ -0,0 +1,68 @@
import hashlib
import json
import os
import re
import secrets
from datetime import datetime, timedelta, timezone
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError
from redis import Redis
from .errors import APIError
password_hasher = PasswordHasher()
dummy_hash = password_hasher.hash(secrets.token_urlsafe(32))
def verify_password(encoded, password):
try:
return password_hasher.verify(encoded or dummy_hash, password) and encoded is not None
except VerificationError:
return False
def unauthorized():
return APIError(401, 'unauthorized', 'Нет действительной идентификации')
class Sessions:
def __init__(self):
self.client = Redis.from_url(
os.getenv('REDIS_URL', 'redis://redis:6379/0'), decode_responses=True,
socket_connect_timeout=1, socket_timeout=1, max_connections=20,
retry_on_timeout=False,
)
self.ttl = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
if self.ttl < 1:
raise ValueError('SESSION_TTL_SECONDS must be positive')
@staticmethod
def key(token):
if not re.fullmatch(r'[A-Za-z0-9_-]{43}', token):
raise unauthorized()
return 'session:' + hashlib.sha256(token.encode('ascii')).hexdigest()
def create(self, user):
token = secrets.token_urlsafe(32)
expires = datetime.now(timezone.utc) + timedelta(seconds=self.ttl)
expires_at = expires.isoformat(timespec='microseconds').replace('+00:00', 'Z')
self.client.set(self.key(token), json.dumps({'user_id': user['id'], 'expires_at': expires_at}),
pxat=int(expires.timestamp() * 1000))
return {'token': token, 'token_type': 'Bearer', 'expires_at': expires_at, 'user': user}
def user_id(self, token):
raw = self.client.get(self.key(token))
if raw is None:
raise unauthorized()
session = json.loads(raw)
if datetime.fromisoformat(session['expires_at'].replace('Z', '+00:00')) <= datetime.now(timezone.utc):
raise unauthorized()
return session['user_id']
def delete(self, token):
if not self.client.delete(self.key(token)):
raise unauthorized()
sessions = Sessions()
+40
View File
@@ -0,0 +1,40 @@
"""History pages are disposable; PostgreSQL owns both data and their version."""
import hashlib
import json
import os
from redis.exceptions import RedisError
from .auth import sessions
class HistoryCache:
def __init__(self, client, ttl=30, prefix='history'):
self.client = client
self.ttl = ttl
self.prefix = prefix
if ttl < 1:
raise ValueError('CACHE_TTL_SECONDS must be positive')
def key(self, chat_id, version, limit, after):
page = json.dumps([limit, after], separators=(',', ':'))
digest = hashlib.sha256(page.encode()).hexdigest()
return f'{self.prefix}:{chat_id}:{version}:{digest}'
def get_or_load(self, chat_id, version, limit, after, load):
key = self.key(chat_id, version, limit, after)
try:
cached = self.client.get(key)
except RedisError:
return load()
if cached is not None:
return json.loads(cached)
page = load()
try:
self.client.set(key, json.dumps(page, ensure_ascii=False), ex=self.ttl)
except RedisError:
pass
return page
history_cache = HistoryCache(sessions.client, int(os.getenv('CACHE_TTL_SECONDS', '30')))
+51
View File
@@ -0,0 +1,51 @@
import os
from pathlib import Path
from sqlalchemy import create_engine, func, insert, select
from sqlalchemy.engine import URL, make_url
from .models import SchemaMigration
def database_url():
if os.getenv('DATABASE_URL'):
url = make_url(os.environ['DATABASE_URL'])
if url.drivername in ('postgres', 'postgresql'):
url = url.set(drivername='postgresql+psycopg')
if url.drivername != 'postgresql+psycopg':
raise ValueError('DATABASE_URL must use PostgreSQL with psycopg')
return url
return URL.create(
'postgresql+psycopg', host=os.getenv('POSTGRES_HOST', 'postgres'),
database=os.getenv('POSTGRES_DB', 'messenger'),
username=os.getenv('POSTGRES_USER', 'messenger'),
password=os.environ['POSTGRES_PASSWORD'],
)
def create_db_engine():
return create_engine(
database_url(), pool_size=10, max_overflow=0, pool_timeout=2, pool_pre_ping=True,
connect_args={'connect_timeout': 2,
'options': '-c statement_timeout=3000 -c lock_timeout=2000'},
)
def migrate(engine):
with engine.begin() as conn:
conn.execute(select(func.pg_advisory_xact_lock(202602)))
SchemaMigration.__table__.create(conn, checkfirst=True)
applied = set(conn.scalars(select(SchemaMigration.version)))
for path in sorted((Path(__file__).resolve().parents[1] / 'migrations').glob('*.sql')):
if path.name not in applied:
conn.exec_driver_sql(path.read_text(encoding='utf-8'))
conn.execute(insert(SchemaMigration).values(version=path.name))
if __name__ == '__main__':
engine = create_db_engine()
try:
migrate(engine)
print('Migrations applied')
finally:
engine.dispose()
+14 -10
View File
@@ -1,7 +1,8 @@
from typing import Optional
from fastapi import Header, Query
from fastapi import Depends, Header, Query
from .auth import sessions, unauthorized
from .errors import APIError
from .store import store
@@ -16,12 +17,15 @@ def page_limit(limit: str = Query(default="50")) -> int:
def current_user(x_user_id: Optional[str] = Header(default=None, alias="X-User-Id")) -> dict:
if not x_user_id:
raise APIError(401, "unauthorized", "Нет действительной идентификации")
try:
return store.require_user(x_user_id)
except APIError as exc:
if exc.status_code == 400:
raise APIError(401, "unauthorized", "Нет действительной идентификации") from exc
raise
def bearer_token(authorization: Optional[str] = Header(default=None)) -> str:
parts = (authorization or '').split()
if len(parts) != 2 or parts[0].lower() != 'bearer':
raise unauthorized()
return parts[1]
def current_user(token: str = Depends(bearer_token)) -> dict:
user = store.get_user(sessions.user_id(token))
if user is None:
raise unauthorized()
return user
+9
View File
@@ -30,9 +30,18 @@ def api_error_handler(request: Request, exc: APIError) -> JSONResponse:
response = error_response(request, exc.status_code, exc.code, exc.message)
if exc.status_code == 429:
response.headers['Retry-After'] = '1'
if exc.status_code == 401:
response.headers['WWW-Authenticate'] = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == '/api/v1/auth/sessions' else 'Bearer realm="messenger"'
)
return response
def dependency_error_handler(request: Request, exc: Exception) -> JSONResponse:
return error_response(request, 503, 'unavailable', 'Хранилище временно недоступно')
def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "invalid_request", "Неверный запрос")
+27 -2
View File
@@ -1,22 +1,47 @@
from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException
from contextlib import asynccontextmanager
from sqlalchemy.exc import OperationalError, InterfaceError, TimeoutError as PoolTimeout
from sqlalchemy.orm import sessionmaker
from redis.exceptions import RedisError
from starlette.concurrency import run_in_threadpool
from .errors import APIError, api_error_handler, validation_error_handler, http_error_handler, internal_error_handler
from .errors import APIError, api_error_handler, validation_error_handler, http_error_handler, internal_error_handler, dependency_error_handler
from .database import create_db_engine, migrate
from .store import store
from .auth import sessions
from .middleware import RequestIdMiddleware
from .limits import ResourceLimitMiddleware
from .routers.health import router as health_router
from .routers.users import router as users_router
from .routers.chats import router as chats_router
from .routers.auth import router as auth_router
app = FastAPI(title="MTUSI Messenger")
@asynccontextmanager
async def lifespan(app):
engine = create_db_engine()
try:
await run_in_threadpool(migrate, engine)
store.sessions = sessionmaker(engine, expire_on_commit=False)
yield
finally:
engine.dispose()
sessions.client.close()
app = FastAPI(title="MTUSI Messenger", lifespan=lifespan)
app.add_middleware(ResourceLimitMiddleware)
app.add_middleware(RequestIdMiddleware)
app.add_exception_handler(APIError, api_error_handler)
app.add_exception_handler(RequestValidationError, validation_error_handler)
app.add_exception_handler(HTTPException, http_error_handler)
app.add_exception_handler(Exception, internal_error_handler)
for error in (OperationalError, InterfaceError, PoolTimeout, RedisError):
app.add_exception_handler(error, dependency_error_handler)
app.include_router(health_router)
app.include_router(users_router)
app.include_router(chats_router)
app.include_router(auth_router)
+3 -1
View File
@@ -9,7 +9,9 @@ class RequestIdMiddleware(BaseHTTPMiddleware):
request_id = request.headers.get("X-Request-Id", "").strip() or str(uuid4())
request.state.request_id = request_id
if request.method in {"POST", "PUT", "PATCH"} and request.url.path.startswith("/api/"):
if (request.method in {"POST", "PUT", "PATCH"}
and request.url.path.startswith("/api/")
and request.url.path != '/api/v1/auth/sessions'):
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if content_type != "application/json":
response = JSONResponse(
+60
View File
@@ -0,0 +1,60 @@
from datetime import datetime
from uuid import uuid4
from sqlalchemy import BigInteger, CheckConstraint, DateTime, ForeignKey, Index, Text, Uuid, func
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = 'users'
__table_args__ = (
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'"),
CheckConstraint('char_length(display_name) BETWEEN 1 AND 100'),
)
id: Mapped[str] = mapped_column(Uuid(as_uuid=False), primary_key=True, default=lambda: str(uuid4()))
username: Mapped[str] = mapped_column(Text, unique=True)
display_name: Mapped[str] = mapped_column(Text)
password_hash: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.clock_timestamp())
class Chat(Base):
__tablename__ = 'chats'
__table_args__ = (
CheckConstraint('char_length(title) BETWEEN 1 AND 100'),
Index('chats_order_idx', 'created_at', 'id'),
)
id: Mapped[str] = mapped_column(Uuid(as_uuid=False), primary_key=True, default=lambda: str(uuid4()))
title: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.clock_timestamp())
history_version: Mapped[int] = mapped_column(BigInteger, server_default='0')
class ChatMember(Base):
__tablename__ = 'chat_members'
__table_args__ = (Index('chat_members_user_idx', 'user_id', 'chat_id'),)
chat_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('chats.id', ondelete='CASCADE'), primary_key=True)
user_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('users.id'), primary_key=True)
class Message(Base):
__tablename__ = 'messages'
__table_args__ = (
CheckConstraint('char_length(text) BETWEEN 1 AND 4000'),
Index('messages_history_idx', 'chat_id', 'created_at', 'id'),
)
id: Mapped[str] = mapped_column(Uuid(as_uuid=False), primary_key=True, default=lambda: str(uuid4()))
chat_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('chats.id', ondelete='CASCADE'))
sender_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('users.id'))
text: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.clock_timestamp())
class SchemaMigration(Base):
__tablename__ = 'schema_migrations'
version: Mapped[str] = mapped_column(Text, primary_key=True)
applied_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=True)
+34
View File
@@ -0,0 +1,34 @@
import base64
from fastapi import APIRouter, Depends, Header, Request, Response
from starlette.concurrency import run_in_threadpool
from ..auth import sessions, unauthorized
from ..dependencies import bearer_token, current_user
from ..errors import APIError
from ..store import store
router = APIRouter(prefix='/api/v1/auth/sessions', tags=['auth'])
@router.post('', status_code=201)
async def create_session(request: Request, authorization: str = Header(default='')):
if await request.body():
raise APIError(400, 'invalid_request', 'Вход не принимает тело запроса')
try:
scheme, encoded = authorization.split()
if scheme.lower() != 'basic':
raise ValueError()
username, password = base64.b64decode(encoded, validate=True).decode('utf-8').split(':', 1)
if not username.isascii() or not 12 <= len(password) <= 128 or '\x00' in username:
raise ValueError()
except (ValueError, UnicodeError):
raise unauthorized() from None
user = await run_in_threadpool(store.login, username, password)
return await run_in_threadpool(sessions.create, user)
@router.delete('/current', status_code=204)
def logout(token: str = Depends(bearer_token), user: dict = Depends(current_user)):
sessions.delete(token)
return Response(status_code=204)
+6
View File
@@ -1,6 +1,9 @@
from fastapi import APIRouter
from sqlalchemy import select
from ..schemas.common import Health
from ..auth import sessions
from ..store import store
router = APIRouter(prefix='/health')
@@ -12,4 +15,7 @@ def health_live():
@router.get("/ready", response_model=Health)
def health_ready():
with store.sessions() as session:
session.execute(select(1))
sessions.client.ping()
return {"status": "ok"}
+1 -1
View File
@@ -11,7 +11,7 @@ router = APIRouter(prefix="/api/v1/users", tags=["users"])
@router.post("", response_model=User, status_code=status.HTTP_201_CREATED)
def create_user(payload: CreateUser):
return store.create_user(payload.username, payload.display_name)
return store.create_user(payload.username, payload.display_name, payload.password)
@router.get("/me", response_model=User)
+9 -1
View File
@@ -1,9 +1,17 @@
from pydantic import BaseModel, ConfigDict
from pydantic import BaseModel, ConfigDict, field_validator
class ContractModel(BaseModel):
model_config = ConfigDict(extra="forbid")
@field_validator('*')
def validate_text_encoding(cls, value, info):
if isinstance(value, str):
value.encode('utf-8')
if info.field_name != 'password' and '\x00' in value:
raise ValueError('NUL is not supported in PostgreSQL text')
return value
class Health(ContractModel):
status: str
+1
View File
@@ -12,6 +12,7 @@ USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
class CreateUser(ContractModel):
username: StrictStr
display_name: StrictStr = Field(min_length=1, max_length=100)
password: StrictStr = Field(min_length=12, max_length=128)
@field_validator("username")
def validate_username(cls, value):
+139 -150
View File
@@ -1,180 +1,169 @@
import base64
import json
import time
from datetime import datetime, timezone
from threading import RLock
from typing import Optional, Tuple
from uuid import UUID, uuid4
from typing import Tuple
from uuid import UUID
from sqlalchemy import select, tuple_, update
from sqlalchemy.exc import IntegrityError
from .auth import password_hasher, verify_password, unauthorized
from .errors import APIError
from .limits import limits
from .cache import history_cache
from .models import User, Chat, ChatMember, Message
def utc_now() -> str:
return datetime.now(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def ensure_uuid(value: str) -> str:
def ensure_uuid(value):
try:
if not isinstance(value, str):
raise ValueError("UUID must be a string")
raise ValueError()
return str(UUID(value))
except (TypeError, ValueError) as exc:
raise APIError(400, "invalid_request", "Неверный UUID") from exc
raise APIError(400, 'invalid_request', 'Неверный UUID') from exc
class InMemoryStore:
def __init__(self, settings=limits):
self.settings = settings
self._lock = RLock()
self._users = {}
self._usernames = set()
self._chats = {}
self._messages = {}
self._message_count = 0
self._text_bytes = 0
self._tokens = float(settings.message_burst)
self._refilled_at = time.monotonic()
def serialize(model, *fields):
if model is None:
return None
result = {}
for field in fields:
value = getattr(model, field)
if isinstance(value, datetime):
value = value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
result[field] = value
return result
def create_user(self, username: str, display_name: str) -> dict:
with self._lock:
if username in self._usernames:
raise APIError(409, "conflict", "Имя пользователя уже занято")
if len(self._users) >= self.settings.max_users:
raise APIError(503, 'unavailable', 'Достигнут лимит пользователей')
user = {
"id": str(uuid4()),
"username": username,
"display_name": display_name,
"created_at": utc_now(),
}
self._users[user["id"]] = user
self._usernames.add(username)
return dict(user)
USER_FIELDS = ('id', 'username', 'display_name', 'created_at')
CHAT_FIELDS = ('id', 'title', 'created_at')
MESSAGE_FIELDS = ('id', 'chat_id', 'sender_id', 'text', 'created_at')
def get_user(self, user_id: str) -> Optional[dict]:
user_id = ensure_uuid(user_id)
with self._lock:
user = self._users.get(user_id)
return dict(user) if user else None
def require_user(self, user_id: str) -> dict:
user = self.get_user(user_id)
if not user:
raise APIError(401, "unauthorized", "Пользователь не авторизован")
return user
def after_condition(model, after):
return tuple_(model.created_at, model.id) > (
datetime.fromisoformat(after[0].replace('Z', '+00:00')), after[1])
def create_chat(self, actor_id: str, title: str, member_ids: list[str]) -> dict:
actor_id = ensure_uuid(actor_id)
normalized_members = [ensure_uuid(member_id) for member_id in member_ids]
if len(normalized_members) != len(set(normalized_members)):
raise APIError(400, "invalid_request", "Участники не должны повторяться")
if actor_id not in normalized_members:
raise APIError(400, "invalid_request", "Создатель должен быть участником чата")
with self._lock:
if any(member_id not in self._users for member_id in normalized_members):
raise APIError(400, "invalid_request", "Неизвестный участник")
if len(self._chats) >= self.settings.max_chats:
raise APIError(503, 'unavailable', 'Достигнут лимит чатов')
def history_query(chat_id, limit, after):
query = select(Message).where(Message.chat_id == chat_id)
if after:
query = query.where(after_condition(Message, after))
return query.order_by(Message.created_at, Message.id).limit(limit + 1)
chat = {
"id": str(uuid4()),
"title": title,
"member_ids": normalized_members,
"created_at": utc_now(),
}
self._chats[chat["id"]] = chat
self._messages[chat["id"]] = []
return self._copy_chat(chat)
def get_chat_for_user(self, chat_id: str, actor_id: str) -> dict:
chat_id = ensure_uuid(chat_id)
actor_id = ensure_uuid(actor_id)
with self._lock:
chat = self._chats.get(chat_id)
if not chat or actor_id not in chat["member_ids"]:
raise APIError(404, "not_found", "Объект не найден")
return self._copy_chat(chat)
class PostgresStore:
def __init__(self, cache=history_cache):
self.sessions = None
self.cache = cache
def list_chats(self, actor_id: str, limit: int, cursor: Optional[str]) -> dict:
actor_id = ensure_uuid(actor_id)
after = self._decode_cursor(cursor, "chats", actor_id) if cursor else None
with self._lock:
chats = [
self._copy_chat(chat)
for chat in self._chats.values()
if actor_id in chat["member_ids"]
]
chats.sort(key=lambda item: (item["created_at"], item["id"]))
if after:
chats = [chat for chat in chats if (chat["created_at"], chat["id"]) > after]
page = chats[:limit]
next_cursor = None
if len(chats) > limit and page:
last = page[-1]
next_cursor = self._encode_cursor("chats", actor_id, last["created_at"], last["id"])
return {"items": page, "next_cursor": next_cursor}
def create_message(self, chat_id: str, actor_id: str, text: str) -> dict:
chat = self.get_chat_for_user(chat_id, actor_id)
def create_user(self, username, display_name, password):
user = User(username=username, display_name=display_name, password_hash=password_hasher.hash(password))
try:
text_size = len(text.encode('utf-8'))
except UnicodeEncodeError as exc:
raise APIError(400, 'invalid_request', 'Некорректный Unicode') from exc
with self._lock:
if self._message_count >= self.settings.max_messages:
raise APIError(503, 'unavailable', 'Достигнут лимит сообщений')
if self._text_bytes + text_size > self.settings.max_text_bytes:
raise APIError(503, 'unavailable', 'Достигнут лимит объёма текста')
now = time.monotonic()
self._tokens = min(self.settings.message_burst,
self._tokens + (now - self._refilled_at) * self.settings.message_rate)
self._refilled_at = now
if self._tokens < 1:
raise APIError(429, 'rate_limited', 'Слишком частая отправка сообщений')
self._tokens -= 1
message = {
"id": str(uuid4()),
"chat_id": chat["id"],
"sender_id": ensure_uuid(actor_id),
"text": text,
"created_at": utc_now(),
}
self._messages[chat["id"]].append(message)
self._message_count += 1
self._text_bytes += text_size
return dict(message)
with self.sessions.begin() as session:
session.add(user)
session.flush()
result = serialize(user, *USER_FIELDS)
return result
except IntegrityError as exc:
if getattr(exc.orig, 'sqlstate', None) == '23505':
raise APIError(409, 'conflict', 'Имя пользователя уже занято') from exc
raise
def list_messages(self, chat_id: str, actor_id: str, limit: int, cursor: Optional[str]) -> dict:
chat = self.get_chat_for_user(chat_id, actor_id)
after = self._decode_cursor(cursor, "messages", chat["id"]) if cursor else None
def get_user(self, user_id):
with self.sessions() as session:
return serialize(session.get(User, ensure_uuid(user_id)), *USER_FIELDS)
with self._lock:
messages = [dict(message) for message in self._messages.get(chat["id"], [])]
messages.sort(key=lambda item: (item["created_at"], item["id"]))
if after:
messages = [
message
for message in messages
if (message["created_at"], message["id"]) > after
]
def login(self, username, password):
with self.sessions() as session:
user = session.scalar(select(User).where(User.username == username))
encoded = user.password_hash if user else None
result = serialize(user, *USER_FIELDS)
if not verify_password(encoded, password):
raise unauthorized()
return result
page = messages[:limit]
next_cursor = None
if len(messages) > limit and page:
last = page[-1]
next_cursor = self._encode_cursor("messages", chat["id"], last["created_at"], last["id"])
return {"items": page, "next_cursor": next_cursor}
def create_chat(self, actor_id, title, member_ids):
members = [ensure_uuid(member) for member in member_ids]
if len(members) != len(set(members)) or actor_id not in members:
raise APIError(400, 'invalid_request', 'Неверный список участников')
try:
with self.sessions.begin() as session:
chat = Chat(title=title)
session.add(chat)
session.flush()
session.add_all([ChatMember(chat_id=chat.id, user_id=member) for member in members])
result = serialize(chat, *CHAT_FIELDS)
result['member_ids'] = sorted(members)
return result
except IntegrityError as exc:
if getattr(exc.orig, 'sqlstate', None) == '23503':
raise APIError(400, 'invalid_request', 'Неизвестный участник') from exc
raise
@staticmethod
def _copy_chat(chat: dict) -> dict:
copy = dict(chat)
copy["member_ids"] = list(chat["member_ids"])
return copy
def _chat(session, chat_id, actor_id):
chat = session.scalar(select(Chat).join(ChatMember).where(
Chat.id == chat_id, ChatMember.user_id == actor_id))
if chat is None:
raise APIError(404, 'not_found', 'Объект не найден')
return chat
@staticmethod
def _members(session, chat):
result = serialize(chat, *CHAT_FIELDS)
result['member_ids'] = list(session.scalars(select(ChatMember.user_id).where(
ChatMember.chat_id == chat.id).order_by(ChatMember.user_id)))
return result
def get_chat_for_user(self, chat_id, actor_id):
with self.sessions() as session:
return self._members(session, self._chat(session, ensure_uuid(chat_id), actor_id))
def list_chats(self, actor_id, limit, cursor):
after = self._decode_cursor(cursor, 'chats', actor_id) if cursor else None
query = select(Chat).join(ChatMember).where(ChatMember.user_id == actor_id)
if after:
query = query.where(after_condition(Chat, after))
query = query.order_by(Chat.created_at, Chat.id).limit(limit + 1)
with self.sessions() as session:
chats = list(session.scalars(query))
items = [self._members(session, chat) for chat in chats[:limit]]
return self._page(items, len(chats) > limit, 'chats', actor_id)
def create_message(self, chat_id, actor_id, text):
chat_id = ensure_uuid(chat_id)
with self.sessions.begin() as session:
self._chat(session, chat_id, actor_id)
session.execute(update(Chat).where(Chat.id == chat_id).values(
history_version=Chat.history_version + 1))
message = Message(chat_id=chat_id, sender_id=actor_id, text=text)
session.add(message)
session.flush()
result = serialize(message, *MESSAGE_FIELDS)
return result
def list_messages(self, chat_id, actor_id, limit, cursor):
chat_id = ensure_uuid(chat_id)
after = self._decode_cursor(cursor, 'messages', chat_id) if cursor else None
with self.sessions() as session:
version = self._chat(session, chat_id, actor_id).history_version
return self.cache.get_or_load(
chat_id, version, limit, after,
lambda: self._load_messages(chat_id, limit, after),
)
def _load_messages(self, chat_id, limit, after):
with self.sessions() as session:
messages = list(session.scalars(history_query(chat_id, limit, after)))
items = [serialize(message, *MESSAGE_FIELDS) for message in messages[:limit]]
return self._page(items, len(messages) > limit, 'messages', chat_id)
def _page(self, items, has_more, resource, owner_id):
cursor = None
if has_more:
last = items[-1]
cursor = self._encode_cursor(resource, owner_id, last['created_at'], last['id'])
return {'items': items, 'next_cursor': cursor}
@staticmethod
def _encode_cursor(resource: str, owner_id: str, created_at: str, item_id: str) -> str:
@@ -215,4 +204,4 @@ class InMemoryStore:
return created_at, item_id
store = InMemoryStore()
store = PostgresStore()