forked from mtusi2026/mtusi2026lab2
494 lines
21 KiB
Python
494 lines
21 KiB
Python
"""Lab 2: stateless HTTP API, PostgreSQL source of truth, durable Redis sessions."""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import binascii
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import secrets
|
|
import uuid
|
|
from contextlib import asynccontextmanager
|
|
from datetime import datetime, timedelta, timezone
|
|
from typing import Any
|
|
|
|
import psycopg
|
|
import redis
|
|
from argon2 import PasswordHasher
|
|
from argon2.exceptions import InvalidHashError, VerificationError
|
|
from fastapi import FastAPI, Query, Request
|
|
from fastapi.concurrency import run_in_threadpool
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse, Response
|
|
from psycopg.errors import UniqueViolation
|
|
from psycopg.rows import dict_row
|
|
from psycopg_pool import ConnectionPool, PoolTimeout
|
|
from pydantic import BaseModel, ConfigDict, Field, field_validator
|
|
|
|
logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO"), format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
|
logger = logging.getLogger("messenger")
|
|
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
|
|
ph = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) # Argon2id; bounded 19 MiB/KDF.
|
|
# Dummy KDF verification on unknown users reduces username-enumeration timing leakage.
|
|
DUMMY_HASH = ph.hash("lab2-dummy-password-not-for-login")
|
|
|
|
|
|
def iso(dt: datetime) -> str:
|
|
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
|
|
|
|
|
class APIError(Exception):
|
|
def __init__(self, status: int, code: str, message: str):
|
|
super().__init__(message)
|
|
self.status, self.code, self.message = status, code, message
|
|
|
|
|
|
class StrictModel(BaseModel):
|
|
model_config = ConfigDict(extra="forbid", strict=True)
|
|
|
|
|
|
class CreateUser(StrictModel):
|
|
username: str
|
|
display_name: str = Field(min_length=1, max_length=100)
|
|
password: str = Field(min_length=12, max_length=128)
|
|
|
|
@field_validator("username")
|
|
@classmethod
|
|
def check_username(cls, v: str) -> str:
|
|
if not USERNAME_RE.fullmatch(v):
|
|
raise ValueError("invalid username")
|
|
return v
|
|
|
|
@field_validator("display_name", "password")
|
|
@classmethod
|
|
def non_blank(cls, v: str) -> str:
|
|
if not v.strip():
|
|
raise ValueError("must not be blank")
|
|
try:
|
|
v.encode("utf-8")
|
|
except UnicodeEncodeError as exc:
|
|
raise ValueError("must be valid UTF-8") from exc
|
|
return v
|
|
|
|
|
|
class CreateChat(StrictModel):
|
|
title: str = Field(min_length=1, max_length=100)
|
|
member_ids: list[str] = Field(min_length=1, max_length=100)
|
|
|
|
@field_validator("title")
|
|
@classmethod
|
|
def non_blank(cls, v: str) -> str:
|
|
if not v.strip():
|
|
raise ValueError("blank title")
|
|
try:
|
|
v.encode("utf-8")
|
|
except UnicodeEncodeError as exc:
|
|
raise ValueError("must be valid UTF-8") from exc
|
|
return v
|
|
|
|
@field_validator("member_ids")
|
|
@classmethod
|
|
def unique(cls, v: list[str]) -> list[str]:
|
|
if len(v) != len(set(v)):
|
|
raise ValueError("duplicate members")
|
|
return v
|
|
|
|
|
|
class CreateMessage(StrictModel):
|
|
text: str = Field(min_length=1, max_length=4000)
|
|
|
|
@field_validator("text")
|
|
@classmethod
|
|
def non_blank(cls, v: str) -> str:
|
|
if not v.strip():
|
|
raise ValueError("blank message")
|
|
try:
|
|
v.encode("utf-8")
|
|
except UnicodeEncodeError as exc:
|
|
raise ValueError("must be valid UTF-8") from exc
|
|
return v
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
url = os.environ.get("DATABASE_URL")
|
|
if not url:
|
|
raise RuntimeError("DATABASE_URL must be provided (do not commit credentials)")
|
|
pool = ConnectionPool(url, min_size=1, max_size=int(os.environ.get("DB_POOL_MAX", "8")),
|
|
timeout=3, max_lifetime=1800,
|
|
kwargs={"row_factory": dict_row, "connect_timeout": 5, "options": "-c statement_timeout=5000"}, open=False)
|
|
pool.open(wait=False)
|
|
app.state.pool = pool
|
|
app.state.sessions = redis.Redis.from_url(os.environ.get("REDIS_URL", "redis://redis:6379/0"),
|
|
socket_connect_timeout=2, socket_timeout=2,
|
|
health_check_interval=10, decode_responses=True)
|
|
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
|
if ttl < 1:
|
|
raise RuntimeError("SESSION_TTL_SECONDS must be >= 1")
|
|
app.state.session_ttl = ttl
|
|
try:
|
|
yield
|
|
finally:
|
|
app.state.sessions.close()
|
|
pool.close()
|
|
|
|
|
|
app = FastAPI(title="MTUCI Messenger Lab 2", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
|
|
|
|
|
|
def reqid(request: Request) -> str:
|
|
return getattr(request.state, "request_id", "unknown")
|
|
|
|
|
|
def error_response(request: Request, status: int, code: str, message: str) -> JSONResponse:
|
|
result = JSONResponse(status_code=status, content={"error": {"code": code, "message": message, "request_id": reqid(request)}})
|
|
if status == 401:
|
|
scheme = 'Basic' if request.url.path == "/api/v1/auth/sessions" else 'Bearer'
|
|
result.headers["WWW-Authenticate"] = (f'Basic realm="messenger", charset="UTF-8"' if scheme == 'Basic' else 'Bearer realm="messenger"')
|
|
return result
|
|
|
|
|
|
@app.middleware("http")
|
|
async def request_context(request: Request, call_next):
|
|
request.state.request_id = uuid.uuid4().hex
|
|
logger.info("request start id=%s method=%s path=%s", reqid(request), request.method, request.url.path)
|
|
try:
|
|
path = request.url.path
|
|
if path == "/api/v1/users/me" or path.startswith("/api/v1/chats") or path == "/api/v1/auth/sessions/current":
|
|
# Authentication precedes resource and body validation.
|
|
request.state.actor = await run_in_threadpool(_authenticate, request)
|
|
if request.method == "POST" and (path in ("/api/v1/users", "/api/v1/chats") or (path.startswith("/api/v1/chats/") and path.endswith("/messages"))):
|
|
mime = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
|
|
if mime != "application/json":
|
|
raise APIError(415, "unsupported_media_type", "Content-Type must be application/json")
|
|
response = await call_next(request)
|
|
except APIError as exc:
|
|
response = error_response(request, exc.status, exc.code, exc.message)
|
|
except (psycopg.Error, PoolTimeout, redis.RedisError):
|
|
logger.warning("dependency unavailable request=%s", reqid(request))
|
|
response = error_response(request, 503, "unavailable", "Required dependency unavailable")
|
|
except Exception:
|
|
logger.exception("unexpected request error id=%s", reqid(request))
|
|
response = error_response(request, 500, "internal_error", "Internal server error")
|
|
response.headers["X-Request-Id"] = reqid(request)
|
|
logger.info("request end id=%s status=%s", reqid(request), response.status_code)
|
|
return response
|
|
|
|
|
|
@app.exception_handler(APIError)
|
|
async def api_error_handler(request: Request, exc: APIError):
|
|
return error_response(request, exc.status, exc.code, exc.message)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error_handler(request: Request, exc: RequestValidationError):
|
|
return error_response(request, 400, "invalid_request", "Invalid request")
|
|
|
|
|
|
@app.exception_handler(psycopg.Error)
|
|
async def db_error_handler(request: Request, exc: psycopg.Error):
|
|
logger.warning("database error request=%s class=%s", reqid(request), type(exc).__name__)
|
|
return error_response(request, 503, "unavailable", "Required dependency unavailable")
|
|
|
|
|
|
@app.exception_handler(PoolTimeout)
|
|
async def pool_error_handler(request: Request, exc: PoolTimeout):
|
|
return error_response(request, 503, "unavailable", "Required dependency unavailable")
|
|
|
|
|
|
@app.exception_handler(redis.RedisError)
|
|
async def redis_error_handler(request: Request, exc: redis.RedisError):
|
|
return error_response(request, 503, "unavailable", "Required dependency unavailable")
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def unexpected_handler(request: Request, exc: Exception):
|
|
logger.exception("unexpected application error request=%s", reqid(request))
|
|
return error_response(request, 500, "internal_error", "Internal server error")
|
|
|
|
|
|
def valid_uuid(raw: str, name: str = "id") -> uuid.UUID:
|
|
try:
|
|
return uuid.UUID(raw)
|
|
except (ValueError, AttributeError, TypeError):
|
|
raise APIError(400, "invalid_request", f"Invalid {name}")
|
|
|
|
|
|
def limit_value(raw: str | None) -> int:
|
|
if raw is None:
|
|
return 50
|
|
if not re.fullmatch(r"[0-9]+", raw):
|
|
raise APIError(400, "invalid_request", "Invalid limit")
|
|
n = int(raw)
|
|
if n < 1 or n > 100:
|
|
raise APIError(400, "invalid_request", "Invalid limit")
|
|
return n
|
|
|
|
|
|
def from_db_utf8(value: bytes | memoryview) -> str:
|
|
"""Decode PostgreSQL bytea; unlike text/varchar it can contain U+0000.
|
|
|
|
The HTTP contract allows the full UTF-8 string range, including an escaped
|
|
JSON NUL. Pydantic checks Unicode code-point lengths before encoding;
|
|
the database enforces a conservative upper bound on byte length.
|
|
"""
|
|
return bytes(value).decode("utf-8")
|
|
|
|
|
|
def user_public(row: dict[str, Any]) -> dict[str, Any]:
|
|
return {"id": str(row["id"]), "username": row["username"], "display_name": from_db_utf8(row["display_name"]), "created_at": iso(row["created_at"])}
|
|
|
|
|
|
def chat_public(row: dict[str, Any]) -> dict[str, Any]:
|
|
return {"id": str(row["id"]), "title": from_db_utf8(row["title"]), "member_ids": [str(x) for x in row["member_ids"]], "created_at": iso(row["created_at"])}
|
|
|
|
|
|
def message_public(row: dict[str, Any]) -> dict[str, Any]:
|
|
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": from_db_utf8(row["text"]), "created_at": iso(row["created_at"])}
|
|
|
|
|
|
def _authenticate(request: Request) -> dict[str, Any]:
|
|
auth = request.headers.get("authorization", "")
|
|
parts = auth.split(" ", 1)
|
|
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1] or not re.fullmatch(r"[A-Za-z0-9_-]+", parts[1]):
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
token = parts[1]
|
|
digest = hashlib.sha256(token.encode("ascii")).hexdigest()
|
|
redis_key = "session:" + digest
|
|
user_id = request.app.state.sessions.get(redis_key)
|
|
if user_id is None:
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
try:
|
|
session_uid = uuid.UUID(user_id)
|
|
except (ValueError, AttributeError, TypeError):
|
|
# Corrupted Redis contents are not an authenticated identity. Fail
|
|
# closed and delete only the broken key, never invent a user or emit 500.
|
|
request.app.state.sessions.delete(redis_key)
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
with request.app.state.pool.connection() as conn:
|
|
row = conn.execute("SELECT id, username, display_name, created_at FROM users WHERE id = %s", (session_uid,)).fetchone()
|
|
if row is None:
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
actor = user_public(row)
|
|
request.state.session_digest = digest
|
|
return actor
|
|
|
|
|
|
def actor(request: Request) -> dict[str, Any]:
|
|
found = getattr(request.state, "actor", None)
|
|
return found if found is not None else _authenticate(request)
|
|
|
|
|
|
def basic_credentials(request: Request) -> tuple[str, str]:
|
|
auth = request.headers.get("authorization", "")
|
|
parts = auth.split(" ", 1)
|
|
if len(parts) != 2 or parts[0].lower() != "basic":
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
try:
|
|
raw = base64.b64decode(parts[1], validate=True).decode("utf-8")
|
|
username, password = raw.split(":", 1)
|
|
except (ValueError, UnicodeError, binascii.Error):
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
if not USERNAME_RE.fullmatch(username) or not password:
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
return username, password
|
|
|
|
|
|
def cursor_encode(payload: dict[str, str]) -> str:
|
|
return base64.urlsafe_b64encode(json.dumps(payload, separators=(",", ":")).encode("ascii")).decode("ascii").rstrip("=")
|
|
|
|
|
|
def cursor_decode(raw: str | None, *, kind: str, scope_key: str, scope_id: str) -> tuple[datetime, uuid.UUID] | None:
|
|
if raw is None:
|
|
return None
|
|
try:
|
|
if not raw or not re.fullmatch(r"[A-Za-z0-9_-]+", raw) or len(raw) > 1500:
|
|
raise ValueError("bad cursor")
|
|
value = json.loads(base64.urlsafe_b64decode(raw + ("=" * (-len(raw) % 4))))
|
|
if not isinstance(value, dict) or set(value) != {"kind", scope_key, "created_at", "id"}:
|
|
raise ValueError("bad cursor fields")
|
|
if value["kind"] != kind or value[scope_key] != scope_id:
|
|
raise ValueError("wrong cursor context")
|
|
stamp = value["created_at"]
|
|
if not isinstance(stamp, str) or not stamp.endswith("Z"):
|
|
raise ValueError("invalid timestamp")
|
|
when = datetime.fromisoformat(stamp.replace("Z", "+00:00"))
|
|
if when.utcoffset() != timedelta(0):
|
|
raise ValueError("not UTC")
|
|
return when, uuid.UUID(value["id"])
|
|
except (ValueError, TypeError, KeyError, UnicodeError, binascii.Error):
|
|
raise APIError(400, "invalid_request", "Invalid cursor")
|
|
|
|
|
|
def cursor_next(kind: str, scope_key: str, scope_id: str, row: dict[str, Any]) -> str:
|
|
return cursor_encode({"kind": kind, scope_key: scope_id, "created_at": iso(row["created_at"]), "id": str(row["id"])})
|
|
|
|
|
|
def read_chat(conn: psycopg.Connection, cid: uuid.UUID, uid: uuid.UUID) -> dict[str, Any]:
|
|
row = conn.execute("""
|
|
SELECT c.id, c.title, c.created_at,
|
|
ARRAY(SELECT cm2.user_id FROM chat_members cm2 WHERE cm2.chat_id=c.id ORDER BY cm2.position) AS member_ids
|
|
FROM chats c JOIN chat_members mine ON mine.chat_id=c.id
|
|
WHERE c.id=%s AND mine.user_id=%s
|
|
""", (cid, uid)).fetchone()
|
|
if row is None:
|
|
raise APIError(404, "not_found", "Object not found")
|
|
return row
|
|
|
|
|
|
@app.get("/health/live")
|
|
def live():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/health/ready")
|
|
def ready(request: Request):
|
|
with request.app.state.pool.connection() as conn:
|
|
conn.execute("SELECT 1")
|
|
request.app.state.sessions.ping()
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.post("/api/v1/users", status_code=201)
|
|
def create_user(body: CreateUser, request: Request):
|
|
new_id = uuid.uuid4()
|
|
hashed = ph.hash(body.password)
|
|
try:
|
|
with request.app.state.pool.connection() as conn:
|
|
row = conn.execute("""
|
|
INSERT INTO users(id, username, display_name, password_hash)
|
|
VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at
|
|
""", (new_id, body.username, body.display_name.encode("utf-8"), hashed)).fetchone()
|
|
except UniqueViolation:
|
|
raise APIError(409, "conflict", "Username already exists")
|
|
return user_public(row)
|
|
|
|
|
|
@app.post("/api/v1/auth/sessions", status_code=201)
|
|
def create_session(request: Request):
|
|
# Contract: this endpoint uses Basic credentials only, never a JSON body.
|
|
if request.headers.get("content-length") not in (None, "", "0") or request.headers.get("transfer-encoding"):
|
|
raise APIError(400, "invalid_request", "Request body is not supported")
|
|
username, password = basic_credentials(request)
|
|
with request.app.state.pool.connection() as conn:
|
|
row = conn.execute("SELECT id, username, display_name, created_at, password_hash FROM users WHERE username=%s", (username,)).fetchone()
|
|
try:
|
|
is_valid = ph.verify(row["password_hash"] if row else DUMMY_HASH, password)
|
|
except (VerificationError, InvalidHashError):
|
|
is_valid = False
|
|
if row is None or not is_valid:
|
|
raise APIError(401, "unauthorized", "Unauthorized")
|
|
token = secrets.token_urlsafe(32) # 32 cryptographically random bytes (256 bits).
|
|
digest = hashlib.sha256(token.encode("ascii")).hexdigest()
|
|
ttl = request.app.state.session_ttl
|
|
request.app.state.sessions.set("session:" + digest, str(row["id"]), ex=ttl)
|
|
expiry = datetime.now(timezone.utc) + timedelta(seconds=ttl)
|
|
return {"token": token, "token_type": "Bearer", "expires_at": iso(expiry), "user": user_public(row)}
|
|
|
|
|
|
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
|
def logout(request: Request):
|
|
actor(request)
|
|
request.app.state.sessions.delete("session:" + request.state.session_digest)
|
|
return Response(status_code=204)
|
|
|
|
|
|
@app.get("/api/v1/users/me")
|
|
def users_me(request: Request):
|
|
return actor(request)
|
|
|
|
|
|
@app.post("/api/v1/chats", status_code=201)
|
|
def create_chat(request: Request, body: CreateChat):
|
|
uid = uuid.UUID(actor(request)["id"])
|
|
members = [valid_uuid(raw, "member_id") for raw in body.member_ids]
|
|
if len(set(members)) != len(members) or uid not in members:
|
|
raise APIError(400, "invalid_request", "Invalid chat members")
|
|
cid = uuid.uuid4()
|
|
with request.app.state.pool.connection() as conn:
|
|
with conn.transaction():
|
|
existing = conn.execute("SELECT id FROM users WHERE id=ANY(%s)", (members,)).fetchall()
|
|
if len(existing) != len(members):
|
|
raise APIError(400, "invalid_request", "Unknown member")
|
|
row = conn.execute("INSERT INTO chats(id, title) VALUES (%s,%s) RETURNING id,title,created_at", (cid, body.title.encode("utf-8"))).fetchone()
|
|
for index, member in enumerate(members):
|
|
conn.execute("INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)", (cid, member, index))
|
|
return chat_public({**row, "member_ids": members})
|
|
|
|
|
|
@app.get("/api/v1/chats")
|
|
def list_chats(request: Request, limit: str | None = Query(default=None), cursor: str | None = Query(default=None)):
|
|
uid = uuid.UUID(actor(request)["id"])
|
|
size = limit_value(limit)
|
|
key = cursor_decode(cursor, kind="chats", scope_key="user_id", scope_id=str(uid))
|
|
with request.app.state.pool.connection() as conn:
|
|
if key:
|
|
match = conn.execute("""
|
|
SELECT 1 FROM chats c JOIN chat_members cm ON c.id=cm.chat_id
|
|
WHERE cm.user_id=%s AND c.id=%s AND c.created_at=%s
|
|
""", (uid, key[1], key[0])).fetchone()
|
|
if match is None:
|
|
raise APIError(400, "invalid_request", "Invalid cursor")
|
|
query = """
|
|
SELECT c.id,c.title,c.created_at,
|
|
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id=c.id ORDER BY m.position) AS member_ids
|
|
FROM chats c JOIN chat_members cm ON cm.chat_id=c.id
|
|
WHERE cm.user_id=%s
|
|
"""
|
|
params: list[Any] = [uid]
|
|
if key:
|
|
query += " AND (c.created_at,c.id)>(%s,%s)"
|
|
params.extend(key)
|
|
query += " ORDER BY c.created_at,c.id LIMIT %s"
|
|
rows = conn.execute(query, [*params, size+1]).fetchall()
|
|
page = rows[:size]
|
|
return {"items": [chat_public(r) for r in page], "next_cursor": cursor_next("chats", "user_id", str(uid), page[-1]) if len(rows)>size else None}
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}")
|
|
def get_chat(chat_id: str, request: Request):
|
|
uid = uuid.UUID(actor(request)["id"])
|
|
with request.app.state.pool.connection() as conn:
|
|
row = read_chat(conn, valid_uuid(chat_id, "chat_id"), uid)
|
|
return chat_public(row)
|
|
|
|
|
|
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
|
def create_message(chat_id: str, request: Request, body: CreateMessage):
|
|
uid = uuid.UUID(actor(request)["id"])
|
|
cid = valid_uuid(chat_id, "chat_id")
|
|
with request.app.state.pool.connection() as conn:
|
|
read_chat(conn, cid, uid)
|
|
row = conn.execute("""
|
|
INSERT INTO messages(id,chat_id,sender_id,text)
|
|
VALUES (%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at
|
|
""", (uuid.uuid4(), cid, uid, body.text.encode("utf-8"))).fetchone()
|
|
return message_public(row)
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}/messages")
|
|
def list_messages(chat_id: str, request: Request, limit: str | None = Query(default=None), cursor: str | None = Query(default=None)):
|
|
uid = uuid.UUID(actor(request)["id"])
|
|
cid = valid_uuid(chat_id, "chat_id")
|
|
size = limit_value(limit)
|
|
key = cursor_decode(cursor, kind="messages", scope_key="chat_id", scope_id=str(cid))
|
|
with request.app.state.pool.connection() as conn:
|
|
read_chat(conn, cid, uid)
|
|
if key:
|
|
found = conn.execute("SELECT 1 FROM messages WHERE chat_id=%s AND id=%s AND created_at=%s", (cid, key[1], key[0])).fetchone()
|
|
if not found:
|
|
raise APIError(400, "invalid_request", "Invalid cursor")
|
|
query = """
|
|
SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s
|
|
"""
|
|
params: list[Any] = [cid]
|
|
if key:
|
|
query += " AND (created_at,id)>(%s,%s)"
|
|
params.extend(key)
|
|
query += " ORDER BY created_at,id LIMIT %s"
|
|
rows = conn.execute(query, [*params, size+1]).fetchall()
|
|
page = rows[:size]
|
|
return {"items": [message_public(r) for r in page], "next_cursor": cursor_next("messages", "chat_id", str(cid), page[-1]) if len(rows)>size else None}
|