feat(backend): alerts come enriched and paged with an unseen count and a live alert frame

backend/src/utils/read/watches.py

@@ -4,13 +4,64 @@ from typing import Any
 
 import asyncpg
 
-from utils.read.models import AlertView, Page, WatchView
+from utils.read import chats as chats_read
+from utils.read import peers as peers_read
+from utils.read.models import (
+    AlertItem,
+    AlertMessage,
+    AlertPage,
+    AlertView,
+    AlertWatch,
+    ChatListItem,
+    ChatRef,
+    PeerView,
+    PersonRef,
+    WatchItem,
+    WatchView,
+)
 
 WATCHES_CHANGED_CHANNEL = "watches_changed"
 ALERTS_CHANGED_CHANNEL = "alerts_changed"
+ALERT_PAGE = 50
+MAX_ALERT_PAGE = 200
 
-_WATCH_COLS = "id, account_id, kind, params, enabled, created_at, updated_at"
+_WATCH_COLS = "id, account_id, kind, name, params, enabled, created_at, updated_at"
 _ALERT_COLS = "id, account_id, watch_id, ts, payload, seen, created_at"
+_LEGACY_EVENTS = {"keyword": "message", "peer_online": "online"}
+
+_INSERT_ALERT = f"""
+WITH alert AS (
+    INSERT INTO alerts (account_id, watch_id, ts, payload, seen, dedup_key)
+    VALUES ($1, $2, $3, $4::jsonb, false, $5)
+    ON CONFLICT (watch_id, dedup_key) WHERE dedup_key IS NOT NULL DO NOTHING
+    RETURNING {_ALERT_COLS}
+), hooks AS (
+    INSERT INTO webhook_deliveries (webhook_id, alert_id, event)
+    SELECT w.id, alert.id, 'alert' FROM alert
+    JOIN webhooks w ON w.account_id = alert.account_id AND w.enabled
+        AND (w.watch_ids IS NULL OR alert.watch_id = ANY(w.watch_ids))
+)
+SELECT * FROM alert
+"""  # noqa: S608
+
+_ALERT_ROWS = """
+SELECT a.id, a.account_id, a.ts, a.seen, a.payload,
+       w.id AS watch_id, w.kind AS watch_kind, w.name AS watch_name,
+       m.text AS stored_text,
+       m.sender_id AS stored_sender, m.date AS stored_date,
+       m.deleted_at IS NOT NULL AS stored_deleted,
+       m.edited_at IS NOT NULL AS stored_edited
+FROM alerts a
+JOIN watches w ON w.id = a.watch_id
+LEFT JOIN LATERAL (
+    SELECT text, sender_id, date, deleted_at, edited_at
+    FROM messages
+    WHERE account_id = a.account_id
+      AND chat_id = (a.payload->>'chat_id')::bigint
+      AND message_id = (a.payload->>'message_id')::bigint
+    ORDER BY date DESC LIMIT 1
+) m ON true
+"""
 
 
 def _to_watch(row: asyncpg.Record) -> WatchView:
@@ -25,6 +76,10 @@ def _to_alert(row: asyncpg.Record) -> AlertView:
     return AlertView(**data)
 
 
+async def _notify(pool: asyncpg.Pool, channel: str, payload: dict[str, Any]) -> None:
+    await pool.execute("SELECT pg_notify($1, $2)", channel, json.dumps(payload))
+
+
 async def list_watches(pool: asyncpg.Pool, account_id: int) -> list[WatchView]:
     rows = await pool.fetch(
         f"SELECT {_WATCH_COLS} FROM watches WHERE account_id = $1 "  # noqa: S608
@@ -42,19 +97,21 @@ async def get_watch(pool: asyncpg.Pool, watch_id: int) -> WatchView | None:
     return _to_watch(row) if row else None
 
 
-async def create_watch(
+async def create_watch(  # noqa: PLR0913
     pool: asyncpg.Pool,
     account_id: int,
     kind: str,
     params: dict[str, Any],
     *,
+    name: str | None = None,
     enabled: bool = True,
 ) -> WatchView:
     row = await pool.fetchrow(
-        "INSERT INTO watches (account_id, kind, params, enabled) "  # noqa: S608
-        f"VALUES ($1, $2, $3::jsonb, $4) RETURNING {_WATCH_COLS}",
+        "INSERT INTO watches (account_id, kind, name, params, enabled) "  # noqa: S608
+        f"VALUES ($1, $2, $3, $4::jsonb, $5) RETURNING {_WATCH_COLS}",
         account_id,
         kind,
+        name,
         json.dumps(params),
         enabled,
     )
@@ -62,13 +119,22 @@ async def create_watch(
     return _to_watch(row)
 
 
-async def update_watch(
-    pool: asyncpg.Pool, watch_id: int, params: dict[str, Any], *, enabled: bool
+async def update_watch(  # noqa: PLR0913
+    pool: asyncpg.Pool,
+    watch_id: int,
+    kind: str,
+    params: dict[str, Any],
+    *,
+    name: str | None,
+    enabled: bool,
 ) -> WatchView | None:
     row = await pool.fetchrow(
-        "UPDATE watches SET params = $2::jsonb, enabled = $3, updated_at = now() "  # noqa: S608
+        "UPDATE watches SET kind = $2, name = $3, params = $4::jsonb, "  # noqa: S608
+        "enabled = $5, updated_at = now() "
         f"WHERE id = $1 RETURNING {_WATCH_COLS}",
         watch_id,
+        kind,
+        name,
         json.dumps(params),
         enabled,
     )
@@ -79,29 +145,198 @@ async def update_watch(
 
 
 async def delete_watch(pool: asyncpg.Pool, watch_id: int) -> bool:
-    result = await pool.execute("DELETE FROM watches WHERE id = $1", watch_id)
-    if not result.endswith("1"):
+    account_id = await pool.fetchval(
+        "DELETE FROM watches WHERE id = $1 RETURNING account_id", watch_id
+    )
+    if account_id is None:
         return False
     await pool.execute(f"NOTIFY {WATCHES_CHANGED_CHANNEL}")
+    await _notify(pool, ALERTS_CHANGED_CHANNEL, {"account_id": account_id})
     return True
 
 
+def _chat_ref(chat_id: int, chat: ChatListItem | None, name: str | None) -> ChatRef:
+    if chat is None:
+        kind = "private" if chat_id > 0 else "group"
+        return ChatRef(id=chat_id, title=name, kind=kind, has_avatar=False)
+    kind = "channel" if chat.is_broadcast else chat.kind
+    return ChatRef(
+        id=chat_id, title=chat.title or name, kind=kind, has_avatar=chat.has_avatar
+    )
+
+
+def _peer_name(peer: PeerView) -> str | None:
+    full = " ".join(part for part in (peer.first_name, peer.last_name) if part)
+    return full or peer.username
+
+
+class Refs:
+    def __init__(self, chats: list[ChatListItem], people: list[PeerView]) -> None:
+        self._chats = {chat.chat_id: chat for chat in chats}
+        self._people = {peer.peer_id: peer for peer in people}
+
+    def chat(self, chat_id: int | None) -> ChatRef | None:
+        if chat_id is None:
+            return None
+        peer = self._people.get(chat_id)
+        name = _peer_name(peer) if peer else None
+        return _chat_ref(chat_id, self._chats.get(chat_id), name)
+
+    def person(self, person_id: int | None) -> PersonRef | None:
+        if person_id is None:
+            return None
+        peer = self._people.get(person_id)
+        chat = self._chats.get(person_id)
+        name = (_peer_name(peer) if peer else None) or (chat.title if chat else None)
+        has_avatar = (peer.has_avatar if peer else False) or bool(
+            chat and chat.has_avatar
+        )
+        return PersonRef(id=person_id, name=name, has_avatar=has_avatar)
+
+
+async def load_refs(
+    pool: asyncpg.Pool, account_id: int, chat_ids: set[int], person_ids: set[int]
+) -> Refs:
+    chats = await chats_read.get_chats(pool, account_id, sorted(chat_ids | person_ids))
+    people = await peers_read.get_peers(
+        pool, account_id, sorted(person_ids | {i for i in chat_ids if i > 0})
+    )
+    return Refs(chats, people)
+
+
+def _int(value: object) -> int | None:
+    return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+
+def _watch_person(params: dict[str, Any]) -> int | None:
+    return _int(params.get("sender_id")) or _int(params.get("peer_id"))
+
+
+async def describe_watches(
+    pool: asyncpg.Pool, account_id: int, watches: list[WatchView]
+) -> list[WatchItem]:
+    targets = [
+        (_int(watch.params.get("chat_id")), _watch_person(watch.params))
+        for watch in watches
+    ]
+    refs = await load_refs(
+        pool,
+        account_id,
+        {chat for chat, _ in targets if chat is not None},
+        {person for _, person in targets if person is not None},
+    )
+    return [
+        WatchItem(
+            **watch.model_dump(), chat=refs.chat(chat), person=refs.person(person)
+        )
+        for watch, (chat, person) in zip(watches, targets, strict=True)
+    ]
+
+
+def _path(chat_id: int | None, message_id: int | None, peer_id: int | None) -> str:
+    if chat_id is not None and message_id is not None:
+        return f"/app/{chat_id}?message={message_id}"
+    if peer_id is not None:
+        return f"/app/{peer_id}"
+    return "/app"
+
+
+def _alert_item(row: asyncpg.Record, refs: Refs) -> AlertItem:
+    payload = json.loads(row["payload"])
+    event = payload.get("event") or _LEGACY_EVENTS.get(row["watch_kind"], "message")
+    chat_id = _int(payload.get("chat_id"))
+    message_id = _int(payload.get("message_id"))
+    peer_id = _int(payload.get("peer_id"))
+    message = None
+    if message_id is not None:
+        date = row["stored_date"] or (
+            datetime.fromisoformat(payload["date"]) if payload.get("date") else None
+        )
+        message = AlertMessage(
+            id=message_id,
+            text=payload.get("text") or row["stored_text"],
+            sender=refs.person(_int(payload.get("sender_id")) or row["stored_sender"]),
+            date=date,
+            deleted=bool(row["stored_deleted"]) or event == "delete",
+            edited=bool(row["stored_edited"]) or event == "edit",
+        )
+    return AlertItem(
+        id=row["id"],
+        account_id=row["account_id"],
+        ts=row["ts"],
+        seen=row["seen"],
+        event=event,
+        watch=AlertWatch(
+            id=row["watch_id"], kind=row["watch_kind"], name=row["watch_name"]
+        ),
+        chat=refs.chat(chat_id),
+        message=message,
+        peer=refs.person(peer_id),
+        path=_path(chat_id, message_id, peer_id),
+    )
+
+
+async def _alert_items(
+    pool: asyncpg.Pool, account_id: int, rows: list[asyncpg.Record]
+) -> list[AlertItem]:
+    chat_ids: set[int] = set()
+    person_ids: set[int] = set()
+    for row in rows:
+        payload = json.loads(row["payload"])
+        for key, bucket in (
+            ("chat_id", chat_ids),
+            ("sender_id", person_ids),
+            ("peer_id", person_ids),
+        ):
+            value = _int(payload.get(key))
+            if value is not None:
+                bucket.add(value)
+        if row["stored_sender"] is not None:
+            person_ids.add(row["stored_sender"])
+    refs = await load_refs(pool, account_id, chat_ids, person_ids)
+    return [_alert_item(row, refs) for row in rows]
+
+
 async def list_alerts(
-    pool: asyncpg.Pool, account_id: int, page: Page, *, seen: bool | None = None
-) -> list[AlertView]:
+    pool: asyncpg.Pool,
+    account_id: int,
+    *,
+    seen: bool | None = None,
+    before: int | None = None,
+    limit: int = ALERT_PAGE,
+) -> AlertPage:
+    size = max(1, min(limit, MAX_ALERT_PAGE))
     params: list[object] = [account_id]
-    where = "account_id = $1"
+    where = "a.account_id = $1"
     if seen is not None:
         params.append(seen)
-        where += f" AND seen = ${len(params)}"
-    params.append(page.capped_limit)
-    params.append(page.offset)
+        where += f" AND a.seen = ${len(params)}"
+    if before is not None:
+        params.append(before)
+        where += f" AND a.id < ${len(params)}"
+    params.append(size + 1)
     rows = await pool.fetch(
-        f"SELECT {_ALERT_COLS} FROM alerts WHERE {where} "  # noqa: S608
-        f"ORDER BY ts DESC LIMIT ${len(params) - 1} OFFSET ${len(params)}",
-        *params,
+        f"{_ALERT_ROWS} WHERE {where} ORDER BY a.id DESC LIMIT ${len(params)}", *params
+    )
+    items = await _alert_items(pool, account_id, rows[:size])
+    return AlertPage(
+        items=items,
+        next_before=items[-1].id if len(rows) > size else None,
+        unseen=await unseen_count(pool, account_id),
+    )
+
+
+async def get_alert(pool: asyncpg.Pool, alert_id: int) -> AlertItem | None:
+    row = await pool.fetchrow(f"{_ALERT_ROWS} WHERE a.id = $1", alert_id)
+    if row is None:
+        return None
+    return (await _alert_items(pool, row["account_id"], [row]))[0]
+
+
+async def unseen_count(pool: asyncpg.Pool, account_id: int) -> int:
+    return await pool.fetchval(
+        "SELECT count(*) FROM alerts WHERE account_id = $1 AND NOT seen", account_id
     )
-    return [_to_alert(row) for row in rows]
 
 
 async def insert_alert(
@@ -113,10 +348,7 @@ async def insert_alert(
     dedup_key: str | None = None,
 ) -> AlertView | None:
     row = await pool.fetchrow(
-        "INSERT INTO alerts (account_id, watch_id, ts, payload, seen, dedup_key) "  # noqa: S608
-        "VALUES ($1, $2, $3, $4::jsonb, false, $5) "
-        "ON CONFLICT (watch_id, dedup_key) WHERE dedup_key IS NOT NULL "
-        f"DO NOTHING RETURNING {_ALERT_COLS}",
+        _INSERT_ALERT,
         account_id,
         watch_id,
         datetime.now(UTC),
@@ -125,10 +357,32 @@ async def insert_alert(
     )
     if row is None:
         return None
-    await pool.execute(f"NOTIFY {ALERTS_CHANGED_CHANNEL}")
+    await _notify(
+        pool, ALERTS_CHANGED_CHANNEL, {"account_id": account_id, "alert_id": row["id"]}
+    )
     return _to_alert(row)
 
 
 async def mark_alert_seen(pool: asyncpg.Pool, alert_id: int) -> bool:
-    result = await pool.execute("UPDATE alerts SET seen = true WHERE id = $1", alert_id)
-    return result.endswith("1")
+    account_id = await pool.fetchval(
+        "UPDATE alerts SET seen = true WHERE id = $1 RETURNING account_id", alert_id
+    )
+    if account_id is None:
+        return False
+    await _notify(pool, ALERTS_CHANGED_CHANNEL, {"account_id": account_id})
+    return True
+
+
+async def mark_all_seen(
+    pool: asyncpg.Pool, account_id: int, up_to: int | None = None
+) -> int:
+    result = await pool.execute(
+        "UPDATE alerts SET seen = true WHERE account_id = $1 AND NOT seen "
+        "AND ($2::int IS NULL OR id <= $2)",
+        account_id,
+        up_to,
+    )
+    marked = int(result.split()[-1])
+    if marked:
+        await _notify(pool, ALERTS_CHANGED_CHANNEL, {"account_id": account_id})
+    return marked