core-framework 0.3.0__py3-none-any.whl

core_framework/application/comments/admin_service.py

@@ -0,0 +1,236 @@
+from asyncio import TaskGroup
+from collections import defaultdict
+from collections.abc import Mapping
+from datetime import datetime
+from typing import Any
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.post.dependencies as post_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.domains.comment import (
+    CommentPreview,
+    CommentStats,
+    CommentStatus,
+    CommentSubjectType,
+    CommentWithMetadata,
+)
+from core_framework.domains.post import PostPreview
+from core_framework.domains.user import UserIdentity
+
+
+async def retrieve_admin_comment_by_id(*, comment_id: str) -> dict[str, Any]:
+    comment = await comment_deps.comment_service.retrieve_comment_with_metadata_by_id(comment_id=comment_id)
+    comment_ids = {comment.id}
+    author_ids = {comment.author_id}
+    post_subject_ids = {comment.subject_id} if comment.subject_type == CommentSubjectType.POST else set()
+    user_wall_subject_ids = {comment.subject_id} if comment.subject_type == CommentSubjectType.USER_WALL else set()
+    parent_comment_ids = {comment.parent_comment_id} if comment.parent_comment_id is not None else set()
+
+    async with TaskGroup() as tg:
+        stats_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_stats_mapping(comment_ids=comment_ids)
+        )
+        post_subject_task = tg.create_task(
+            post_deps.post_service.retrieve_post_preview_mapping(post_ids=post_subject_ids)
+        )
+        parent_comment_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_preview_mapping(comment_ids=parent_comment_ids)
+        )
+
+    comment_stats_mapping = stats_task.result()
+    post_subject_mapping = post_subject_task.result()
+    parent_comment_mapping = parent_comment_task.result()
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(
+        user_ids=(
+            author_ids
+            | user_wall_subject_ids
+            | {item.author_id for item in post_subject_mapping.values()}
+            | {item.author_id for item in parent_comment_mapping.values()}
+        )
+    )
+    return _serialize_admin_comment(
+        comment=comment,
+        comment_stats_mapping=comment_stats_mapping,
+        user_identity_mapping=user_identity_mapping,
+        post_subject_mapping=post_subject_mapping,
+        parent_comment_mapping=parent_comment_mapping,
+    )
+
+
+async def retrieve_admin_comments(
+    *,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    comments = await comment_deps.comment_service.retrieve_comments_with_metadata(cursor=cursor, limit=limit)
+    if not comments:
+        return []
+
+    comment_ids = {comment.id for comment in comments}
+    author_ids = {comment.author_id for comment in comments}
+    post_subject_ids = {comment.subject_id for comment in comments if comment.subject_type == CommentSubjectType.POST}
+    user_wall_subject_ids = {
+        comment.subject_id for comment in comments if comment.subject_type == CommentSubjectType.USER_WALL
+    }
+    parent_comment_ids = {comment.parent_comment_id for comment in comments if comment.parent_comment_id is not None}
+
+    async with TaskGroup() as tg:
+        stats_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_stats_mapping(comment_ids=comment_ids)
+        )
+        post_subject_task = tg.create_task(
+            post_deps.post_service.retrieve_post_preview_mapping(post_ids=post_subject_ids)
+        )
+        parent_comment_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_preview_mapping(comment_ids=parent_comment_ids)
+        )
+
+    comment_stats_mapping = stats_task.result()
+    post_subject_mapping = post_subject_task.result()
+    parent_comment_mapping = parent_comment_task.result()
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(
+        user_ids=(
+            author_ids
+            | user_wall_subject_ids
+            | {item.author_id for item in post_subject_mapping.values()}
+            | {item.author_id for item in parent_comment_mapping.values()}
+        )
+    )
+    return [
+        _serialize_admin_comment(
+            comment=comment,
+            comment_stats_mapping=comment_stats_mapping,
+            user_identity_mapping=user_identity_mapping,
+            post_subject_mapping=post_subject_mapping,
+            parent_comment_mapping=parent_comment_mapping,
+        )
+        for comment in comments
+    ]
+
+
+async def set_comment_inactive(*, comment_id: str) -> str | None:
+    return await comment_deps.comment_service.set_comment_status_by_id(
+        comment_id=comment_id,
+        status=CommentStatus.DELETED,
+    )
+
+
+async def restore_comment(*, comment_id: str) -> str | None:
+    return await comment_deps.comment_service.set_comment_status_by_id(
+        comment_id=comment_id,
+        status=CommentStatus.ACTIVE,
+    )
+
+
+async def remove_comment(*, comment_id: str) -> str | None:
+    parent_comment_id = await comment_deps.comment_service.retrieve_parent_comment_id_strong(comment_id=comment_id)
+    comment_ids = await comment_deps.comment_service.retrieve_comment_subtree_ids_strong(root_comment_id=comment_id)
+    if not comment_ids:
+        return None
+
+    await moderation_deps.moderation_service.remove_comment_reports_by_target_ids(target_ids=comment_ids)
+    await comment_deps.comment_service.remove_comment_subtree(root_comment_id=comment_id)
+    return parent_comment_id
+
+
+def _serialize_admin_comment(
+    *,
+    comment: CommentWithMetadata,
+    comment_stats_mapping: defaultdict[str, CommentStats],
+    user_identity_mapping: defaultdict[str, UserIdentity],
+    post_subject_mapping: Mapping[str, PostPreview],
+    parent_comment_mapping: Mapping[str, CommentPreview],
+) -> dict[str, Any]:
+    stats = comment_stats_mapping[comment.id]
+    return {
+        "id": comment.id,
+        "author": _serialize_user_reference(user_identity_mapping=user_identity_mapping, user_id=comment.author_id),
+        "content": comment.content,
+        "subject": _serialize_subject(
+            comment=comment,
+            user_identity_mapping=user_identity_mapping,
+            post_subject_mapping=post_subject_mapping,
+        ),
+        "parent_comment": _serialize_parent_comment(
+            comment=comment,
+            user_identity_mapping=user_identity_mapping,
+            parent_comment_mapping=parent_comment_mapping,
+        ),
+        "status": comment.status,
+        "edited_count": comment.edited_count,
+        "stats": {
+            "like_count": stats.like_count,
+            "reply_count": stats.reply_count,
+            "report_count": stats.report_count,
+        },
+        "edited_at": comment.edited_at,
+        "created_at": comment.created_at,
+    }
+
+
+def _serialize_subject(
+    *,
+    comment: CommentWithMetadata,
+    user_identity_mapping: defaultdict[str, UserIdentity],
+    post_subject_mapping: Mapping[str, PostPreview],
+) -> dict[str, Any]:
+    if comment.subject_type == CommentSubjectType.POST:
+        post_subject = post_subject_mapping[comment.subject_id]
+        return {
+            "subject_type": comment.subject_type,
+            "post_id": comment.subject_id,
+            "author": _serialize_user_reference(
+                user_identity_mapping=user_identity_mapping,
+                user_id=post_subject.author_id,
+            ),
+            "content_preview": _serialize_content_preview(post_subject.content),
+        }
+
+    return {
+        "subject_type": comment.subject_type,
+        "user": _serialize_user_reference(
+            user_identity_mapping=user_identity_mapping,
+            user_id=comment.subject_id,
+        ),
+    }
+
+
+def _serialize_parent_comment(
+    *,
+    comment: CommentWithMetadata,
+    user_identity_mapping: defaultdict[str, UserIdentity],
+    parent_comment_mapping: Mapping[str, CommentPreview],
+) -> dict[str, Any] | None:
+    if comment.parent_comment_id is None:
+        return None
+
+    parent_comment = parent_comment_mapping[comment.parent_comment_id]
+    return {
+        "comment_id": comment.parent_comment_id,
+        "author": _serialize_user_reference(
+            user_identity_mapping=user_identity_mapping,
+            user_id=parent_comment.author_id,
+        ),
+        "content_preview": _serialize_content_preview(parent_comment.content),
+        "status": parent_comment.status,
+    }
+
+
+def _serialize_user_reference(
+    *,
+    user_identity_mapping: defaultdict[str, UserIdentity],
+    user_id: str,
+) -> dict[str, Any]:
+    identity = user_identity_mapping[user_id]
+    return {
+        "user_id": user_id,
+        "username": identity.username,
+        "display_name": identity.display_name,
+    }
+
+
+def _serialize_content_preview(content: str) -> str:
+    if content.strip():
+        return content
+    return "[preview unavailable]"

core_framework/application/comments/aggregation_service.py

@@ -0,0 +1,28 @@
+from asyncio import TaskGroup
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+
+
+async def aggregate_comment_stats(*, comment_id: str) -> None:
+    async with TaskGroup() as tg:
+        like_task = tg.create_task(comment_deps.comment_service.retrieve_comment_like_count(comment_id=comment_id))
+        reply_task = tg.create_task(comment_deps.comment_service.retrieve_comment_reply_count(comment_id=comment_id))
+        report_task = tg.create_task(
+            moderation_deps.moderation_service.retrieve_comment_report_count(comment_id=comment_id)
+        )
+
+    await comment_deps.comment_service.update_comment_stats(
+        comment_id=comment_id,
+        like_count=like_task.result(),
+        reply_count=reply_task.result(),
+        report_count=report_task.result(),
+    )
+
+
+async def claim_comment_ids_dirty() -> list[str]:
+    return await comment_deps.comment_service.claim_comment_ids_dirty()
+
+
+async def mark_comment_stats_dirty(*, comment_id: str) -> None:
+    await comment_deps.comment_service.insert_comment_stats_dirty(comment_id=comment_id)

core_framework/application/comments/authenticated_service.py

@@ -0,0 +1,89 @@
+from typing import Any
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+from core_framework.application.comments import aggregation_service as comment_aggregation_service
+from core_framework.domains.comment import CommentSubjectType
+from core_framework.domains.moderation import ReportCategory
+
+
+async def create_comment(
+    *,
+    author_id: str,
+    content: str,
+    subject_type: CommentSubjectType,
+    subject_id: str,
+) -> None:
+    await comment_deps.comment_service.add_comment(
+        author_id=author_id,
+        content=content,
+        subject_type=subject_type,
+        subject_id=subject_id,
+    )
+
+
+async def create_reply(
+    *,
+    author_id: str,
+    content: str,
+    parent_comment_id: str,
+) -> None:
+    await comment_deps.comment_service.add_reply(
+        author_id=author_id,
+        content=content,
+        parent_comment_id=parent_comment_id,
+    )
+
+
+async def edit_comment(
+    *,
+    comment_id: str,
+    author_id: str,
+    validated_update_request: dict[str, Any],
+) -> None:
+    await comment_deps.comment_service.edit_comment(
+        comment_id=comment_id,
+        author_id=author_id,
+        validated_update_request=validated_update_request,
+    )
+
+
+async def like_comment(*, comment_id: str, user_id: str) -> None:
+    await comment_deps.comment_service.add_comment_like(comment_id=comment_id, liker_id=user_id)
+
+
+async def unlike_comment(*, comment_id: str, user_id: str) -> None:
+    await comment_deps.comment_service.remove_comment_like(comment_id=comment_id, liker_id=user_id)
+
+
+async def add_comment_report(
+    *,
+    reporter_id: str,
+    comment_id: str,
+    category: ReportCategory,
+    reason: str,
+) -> None:
+    await moderation_deps.moderation_service.add_comment_report(
+        reporter_id=reporter_id,
+        target_id=comment_id,
+        category=category,
+        reason=reason,
+    )
+
+
+async def remove_comment_report(*, reporter_id: str, comment_id: str) -> None:
+    await moderation_deps.moderation_service.remove_comment_report_by_reporter(
+        reporter_id=reporter_id,
+        target_id=comment_id,
+    )
+
+
+async def delete_comment(*, comment_id: str, author_id: str) -> str | None:
+    return await comment_deps.comment_service.remove_comment(
+        comment_id=comment_id,
+        author_id=author_id,
+    )
+
+
+async def mark_comment_stats_dirty(*, comment_id: str) -> None:
+    await comment_aggregation_service.mark_comment_stats_dirty(comment_id=comment_id)

core_framework/application/comments/public_service.py

@@ -0,0 +1,218 @@
+from asyncio import TaskGroup
+from collections import defaultdict
+from datetime import datetime
+from typing import Any
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.domains.comment import Comment, CommentStats, CommentSubjectType
+from core_framework.domains.user import REDACTED_AUTHOR_ID, UserIdentity
+
+
+async def _retrieve_viewer_context_ids(
+    *,
+    viewer_id: str | None,
+    comment_ids: set[str],
+) -> tuple[frozenset[str] | None, frozenset[str] | None]:
+    if viewer_id is None or not comment_ids:
+        return None, None
+    async with TaskGroup() as tg:
+        liked_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_ids_liked_by_user(
+                liker_id=viewer_id,
+                comment_ids=comment_ids,
+            )
+        )
+        reported_task = tg.create_task(
+            moderation_deps.moderation_service.retrieve_comment_ids_reported_by_user(
+                reporter_id=viewer_id,
+                comment_ids=comment_ids,
+            )
+        )
+    return liked_task.result(), reported_task.result()
+
+
+def _serialize_comment(
+    *,
+    comment: Comment,
+    comment_stats_mapping: defaultdict[str, CommentStats],
+    user_identity_mapping: defaultdict[str, UserIdentity],
+    viewer_id: str | None = None,
+    liked_ids: frozenset[str] | None = None,
+    reported_ids: frozenset[str] | None = None,
+) -> dict[str, Any]:
+    stats = comment_stats_mapping[comment.id]
+    author_identity = user_identity_mapping[comment.author_id]
+    viewer_context = None
+    if liked_ids is not None and reported_ids is not None:
+        viewer_context = {
+            "is_liked": comment.id in liked_ids,
+            "is_reported": comment.id in reported_ids,
+        }
+    author_context = None
+    if viewer_id is not None and viewer_id == comment.author_id:
+        author_context = {
+            "can_edit": comment.edited_count < comment_deps.comment_service.MAX_EDIT_COUNT,
+            "can_delete": True,
+        }
+    return {
+        "id": comment.id,
+        "author": {
+            "user_id": comment.author_id,
+            "username": author_identity.username,
+            "display_name": author_identity.display_name,
+        },
+        "content": comment.content,
+        "stats": {
+            "like_count": stats.like_count,
+            "reply_count": stats.reply_count,
+        },
+        "can_reply": comment.level < comment_deps.comment_service.MAX_REPLY_LEVEL,
+        "engagement_allowed": comment.author_id != REDACTED_AUTHOR_ID,
+        "edited_at": comment.edited_at,
+        "created_at": comment.created_at,
+        "viewer_context": viewer_context,
+        "author_context": author_context,
+    }
+
+
+async def retrieve_comments(
+    *,
+    subject_type: CommentSubjectType,
+    subject_id: str,
+    cursor: datetime,
+    limit: int,
+    viewer_id: str | None,
+) -> list[dict[str, Any]]:
+    comments = await comment_deps.comment_service.retrieve_comments_by_subject(
+        subject_type=subject_type,
+        subject_id=subject_id,
+        cursor=cursor,
+        limit=limit,
+        viewer_id=viewer_id,
+    )
+    comment_ids = {c.id for c in comments}
+    author_ids = {c.author_id for c in comments}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, comment_ids=comment_ids))
+        stats_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_stats_mapping(comment_ids=comment_ids)
+        )
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    comment_stats_mapping = stats_task.result()
+    user_identity_mapping = identity_task.result()
+    return [
+        _serialize_comment(
+            comment=comment,
+            comment_stats_mapping=comment_stats_mapping,
+            user_identity_mapping=user_identity_mapping,
+            viewer_id=viewer_id,
+            liked_ids=liked_ids,
+            reported_ids=reported_ids,
+        )
+        for comment in comments
+    ]
+
+
+async def retrieve_comments_by_user_id(
+    *,
+    user_id: str,
+    cursor: datetime,
+    limit: int,
+    viewer_id: str | None,
+) -> list[dict[str, Any]]:
+    comments = await comment_deps.comment_service.retrieve_comments_by_author_id(
+        author_id=user_id,
+        cursor=cursor,
+        limit=limit,
+        viewer_id=viewer_id,
+    )
+    comment_ids = {c.id for c in comments}
+    author_ids = {c.author_id for c in comments}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, comment_ids=comment_ids))
+        stats_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_stats_mapping(comment_ids=comment_ids)
+        )
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    comment_stats_mapping = stats_task.result()
+    user_identity_mapping = identity_task.result()
+    return [
+        _serialize_comment(
+            comment=comment,
+            comment_stats_mapping=comment_stats_mapping,
+            user_identity_mapping=user_identity_mapping,
+            viewer_id=viewer_id,
+            liked_ids=liked_ids,
+            reported_ids=reported_ids,
+        )
+        for comment in comments
+    ]
+
+
+async def retrieve_replies(
+    *,
+    parent_comment_id: str,
+    cursor: datetime,
+    limit: int,
+    viewer_id: str | None,
+) -> list[dict[str, Any]]:
+    comments = await comment_deps.comment_service.retrieve_replies_by_parent_id(
+        parent_comment_id=parent_comment_id,
+        cursor=cursor,
+        limit=limit,
+        viewer_id=viewer_id,
+    )
+    comment_ids = {c.id for c in comments}
+    author_ids = {c.author_id for c in comments}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, comment_ids=comment_ids))
+        stats_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_stats_mapping(comment_ids=comment_ids)
+        )
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    comment_stats_mapping = stats_task.result()
+    user_identity_mapping = identity_task.result()
+    return [
+        _serialize_comment(
+            comment=comment,
+            comment_stats_mapping=comment_stats_mapping,
+            user_identity_mapping=user_identity_mapping,
+            viewer_id=viewer_id,
+            liked_ids=liked_ids,
+            reported_ids=reported_ids,
+        )
+        for comment in comments
+    ]
+
+
+async def retrieve_comment_by_id(*, comment_id: str, viewer_id: str | None) -> dict[str, Any] | None:
+    comment = await comment_deps.comment_service.retrieve_comment_by_id(
+        comment_id=comment_id,
+        viewer_id=viewer_id,
+    )
+    if comment is None:
+        return None
+    comment_ids = {comment.id}
+    author_ids = {comment.author_id}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, comment_ids=comment_ids))
+        stats_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_stats_mapping(comment_ids=comment_ids)
+        )
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    comment_stats_mapping = stats_task.result()
+    user_identity_mapping = identity_task.result()
+    return _serialize_comment(
+        comment=comment,
+        comment_stats_mapping=comment_stats_mapping,
+        user_identity_mapping=user_identity_mapping,
+        viewer_id=viewer_id,
+        liked_ids=liked_ids,
+        reported_ids=reported_ids,
+    )

core_framework/application/events/README.md

@@ -0,0 +1,26 @@
+# Events Application Layer
+
+Handles fire-and-forget event recording for analytics and telemetry.
+
+## Event Types
+
+### LOGIN
+
+- Records user login telemetry in `user_login_events`
+- **user_id source**: Authenticated Firebase user (`viewer_id` from request context), not the event payload
+- Unauthenticated requests are accepted (202) but no event is recorded
+- Fire-and-forget: errors are logged, not raised
+
+### VIEW
+
+- Records post view events in `post_views`
+- Uses `subject` from each event as `post_id`
+- Fire-and-forget: errors are logged, not raised
+
+## Flow
+
+1. Client obtains a token via `GET /events/token`
+1. Client posts events via `POST /events` with `type`, `token`, and `events`
+1. Token is verified; invalid tokens cause early return (still 202)
+1. Handler runs in background task
+1. Handlers are keyed by `EventType`; unknown types are ignored

core_framework/application/events/event_service.py

@@ -0,0 +1,51 @@
+from collections.abc import Callable
+from typing import Any
+
+from loguru import logger
+
+import core_framework.domains.post.dependencies as post_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.application.events.models import Event
+from core_framework.application.shared.enums import EventType, SubjectType
+
+
+async def record_login_events(
+    *,
+    events: list[Event],
+    token: str,
+    request_context: dict[str, str],
+) -> None:
+    viewer_id = request_context.get("viewer_id")
+    if not viewer_id:
+        return
+    try:
+        await user_deps.user_service.add_login_event(
+            user_id=viewer_id,
+            request_context=request_context,
+        )
+    except Exception:
+        logger.warning("Login event recording failed (fire-and-forget, acceptable to ignore)")
+
+
+async def record_view_events(
+    *,
+    events: list[Event],
+    token: str,
+    request_context: dict[str, str],
+) -> None:
+    for event in events:
+        try:
+            if event.subject_type == SubjectType.POST:
+                await post_deps.post_service.add_post_view(
+                    post_id=event.subject,
+                    token=token,
+                    request_context=request_context,
+                )
+        except Exception:
+            logger.warning("View event recording failed (fire-and-forget, acceptable to ignore)")
+
+
+EVENT_HANDLERS: dict[EventType, Callable[..., Any]] = {
+    EventType.VIEW: record_view_events,
+    EventType.LOGIN: record_login_events,
+}

core_framework/application/events/event_token.py

@@ -0,0 +1,46 @@
+from itsdangerous import BadSignature, SignatureExpired, URLSafeTimedSerializer
+from loguru import logger
+
+from core_framework.application.shared.enums import EventType
+
+EVENT_TOKEN_MAX_AGE_VIEW_SECONDS: int = 600  # 10 minutes
+_configured_secret_key: str | None = None
+
+
+def configure_event_token(*, secret_key: str) -> None:
+    global _configured_secret_key
+    _configured_secret_key = secret_key
+
+
+def _build_serializer(secret_key: str) -> URLSafeTimedSerializer:
+    return URLSafeTimedSerializer(secret_key, salt="event-token")
+
+
+def _get_serializer() -> URLSafeTimedSerializer:
+    if _configured_secret_key is None:
+        msg = "Event token is not configured. Call configure_event_token() during application bootstrap."
+        raise RuntimeError(msg)
+    return _build_serializer(_configured_secret_key)
+
+
+_EVENT_MAX_AGE: dict[EventType, int | None] = {
+    EventType.VIEW: EVENT_TOKEN_MAX_AGE_VIEW_SECONDS,
+    EventType.LOGIN: None,
+}
+
+
+def generate_token() -> str:
+    return _get_serializer().dumps("")
+
+
+def verify_token(token: str, *, event_type: EventType) -> bool:
+    max_age = _EVENT_MAX_AGE.get(event_type)
+    try:
+        _get_serializer().loads(token, max_age=max_age)
+        return True
+    except SignatureExpired:
+        logger.warning("Event token verification failed: token expired")
+        return False
+    except BadSignature:
+        logger.warning("Event token verification failed: invalid or tampered token")
+        return False