Recovered orphaned WIP before switching to a new task

backend/alembic/versions/0002_add_date_of_birth_to_users.py

@@ -0,0 +1,30 @@
+"""add date_of_birth column to users table
+
+Revision ID: 0002_add_date_of_birth_to_users
+Revises: 0001_initial
+Create Date: 2025-01-01 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = "0002_add_date_of_birth_to_users"
+down_revision: Union[str, None] = "0001_initial"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Add date_of_birth column to users table."""
+    op.add_column(
+        "users",
+        sa.Column("date_of_birth", sa.Date(), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    """Remove date_of_birth column from users table."""
+    op.drop_column("users", "date_of_birth")

backend/alembic/versions/2a9b9873244a_add_presence_columns.py

@@ -1,29 +0,0 @@
-"""add presence columns to users
-
-Revision ID: 2a9b9873244a
-Revises: 0001_initial
-Create Date: 2026-08-18 15:59:09.298919
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '2a9b9873244a'
-down_revision: Union[str, None] = '0001_initial'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Add last_seen_at and status_message columns to users table."""
-    op.add_column('users', sa.Column('last_seen_at', sa.DateTime(timezone=True), nullable=True))
-    op.add_column('users', sa.Column('status_message', sa.Text(), nullable=True))
-
-
-def downgrade() -> None:
-    """Remove presence columns from users table."""
-    op.drop_column('users', 'status_message')
-    op.drop_column('users', 'last_seen_at')

backend/app/main.py

@@ -6,7 +6,7 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.config import settings
-from app.routers import auth, users, worlds, assets, presence
+from app.routers import auth, users, worlds, assets
 
 
 @asynccontextmanager
@@ -38,7 +38,6 @@ app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
 app.include_router(users.router, prefix="/api/users", tags=["users"])
 app.include_router(worlds.router, prefix="/api/worlds", tags=["worlds"])
 app.include_router(assets.router, prefix="/api/assets", tags=["assets"])
-app.include_router(presence.router, prefix="/api/presence", tags=["presence"])
 
 
 @app.get("/api/health")

backend/app/models/user.py

@@ -1,4 +1,7 @@
-from sqlalchemy import Column, Integer, String, Boolean, DateTime, Text
+from datetime import date
+from typing import Optional
+
+from sqlalchemy import Column, Integer, String, Boolean, DateTime, Date
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 
@@ -12,14 +15,23 @@ class User(Base):
     username = Column(String(50), unique=True, index=True, nullable=False)
     email = Column(String(120), unique=True, index=True, nullable=False)
     hashed_password = Column(String(255), nullable=False)
+    date_of_birth = Column(Date, nullable=True)
     is_active = Column(Boolean, default=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
     updated_at = Column(DateTime(timezone=True), onupdate=func.now())
 
-    # Presence / status
-    last_seen_at = Column(DateTime(timezone=True), nullable=True)
-    status_message = Column(Text, nullable=True)
-
     sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan")
     worlds = relationship("World", back_populates="owner")
     assets = relationship("Asset", back_populates="owner")
+
+    @property
+    def is_adult(self) -> bool:
+        """Return True if the user is 18 or older based on date_of_birth."""
+        if self.date_of_birth is None:
+            return False
+        today = date.today()
+        age = today.year - self.date_of_birth.year
+        # Adjust if birthday hasn't occurred yet this year
+        if (today.month, today.day) < (self.date_of_birth.month, self.date_of_birth.day):
+            age -= 1
+        return age >= 18

backend/app/routers/auth.py

@@ -1,10 +1,10 @@
 """Authentication router - login, register, token refresh."""
 
-from datetime import datetime, timedelta, timezone
+from datetime import date, datetime, timedelta, timezone
 
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordRequestForm
-from pydantic import BaseModel, EmailStr
+from pydantic import BaseModel, EmailStr, field_validator
 
 from jose import jwt
 from passlib.context import CryptContext
@@ -32,12 +32,24 @@ class RegisterRequest(BaseModel):
     username: str
     email: EmailStr
     password: str
+    date_of_birth: str  # ISO format date string (YYYY-MM-DD)
+
+    @field_validator("date_of_birth")
+    @classmethod
+    def validate_date_of_birth(cls, v: str) -> str:
+        """Validate that the date string is a valid date in YYYY-MM-DD format."""
+        try:
+            datetime.strptime(v, "%Y-%m-%d")
+        except ValueError:
+            raise ValueError("date_of_birth must be in YYYY-MM-DD format")
+        return v
 
 
 class UserResponse(BaseModel):
     id: int
     username: str
     email: str
+    date_of_birth: str | None = None
     is_active: bool
     created_at: datetime | None = None
 
@@ -65,11 +77,44 @@ def hash_password(password: str) -> str:
     return pwd_context.hash(password)
 
 
+def calculate_age(birth_date: date, today: date | None = None) -> int:
+    """Calculate age in years from a birth date.
+
+    Args:
+        birth_date: The person's date of birth.
+        today: The reference date. Defaults to today's date (UTC).
+
+    Returns:
+        Age in whole years as of the reference date.
+    """
+    if today is None:
+        today = datetime.now(timezone.utc).date()
+
+    age = today.year - birth_date.year
+    # Adjust if birthday hasn't occurred yet this year
+    if (today.month, today.day) < (birth_date.month, birth_date.day):
+        age -= 1
+    return age
+
+
 # --- Endpoints ---
 
 @router.post("/register", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
 async def register(req: RegisterRequest, db: AsyncSession = Depends(get_db)):
-    """Register a new user and return an access token."""
+    """Register a new user and return an access token.
+
+    Requires date_of_birth and rejects users under 18.
+    """
+    # Parse and validate date_of_birth
+    dob = datetime.strptime(req.date_of_birth, "%Y-%m-%d").date()
+    age = calculate_age(dob)
+
+    if age < 18:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Must be 18 or older to register (provided date of birth: {req.date_of_birth})",
+        )
+
     # Check if username already exists
     result = await db.execute(select(User).where(User.username == req.username))
     if result.scalar_one_or_none():
@@ -90,6 +135,7 @@ async def register(req: RegisterRequest, db: AsyncSession = Depends(get_db)):
         username=req.username,
         email=req.email,
         hashed_password=hash_password(req.password),
+        date_of_birth=dob,
     )
     db.add(user)
     await db.commit()

backend/app/routers/presence.py

@@ -1,155 +0,0 @@
-"""Presence & status router.
-
-Endpoints:
-- POST /api/presence/heartbeat  – record a heartbeat (sets Redis TTL key)
-- GET  /api/presence/presence   – query presence for a list of user ids
-- PATCH /api/presence/status    – update the authenticated user's status message
-"""
-
-from datetime import datetime, timezone
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, HTTPException, status
-from pydantic import BaseModel, Field, field_validator
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.config import settings
-from app.database import get_db
-from app.dependencies import CurrentUser
-from app.models.user import User
-from app.services.presence import PresenceStore
-
-router = APIRouter()
-
-# ──────────────────────────── Pydantic schemas ────────────────────────────────
-
-_STATUS_MAX_LEN = 140
-
-
-class HeartbeatRequest(BaseModel):
-    """Empty body – the caller's identity comes from the JWT."""
-
-
-class PresenceUser(BaseModel):
-    user_id: int
-    is_online: bool
-    last_seen_at: datetime | None
-    status_message: str | None
-
-
-class PresenceResponse(BaseModel):
-    users: list[PresenceUser]
-
-
-class StatusUpdate(BaseModel):
-    status_message: str | None = Field(default=None, max_length=_STATUS_MAX_LEN)
-
-    @field_validator("status_message")
-    @classmethod
-    def strip_message(cls, v: str | None) -> str | None:
-        if v is not None:
-            v = v.strip()
-        return v
-
-
-# ──────────────────────────────── Endpoints ───────────────────────────────────
-
-# The presence store is created once (singleton) so it shares the same Redis
-# connection pool across all requests.
-_presence_store = PresenceStore()
-
-
-@router.post("/heartbeat", response_model=dict)
-async def heartbeat(
-    _req: HeartbeatRequest,
-    current_user: CurrentUser,
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    """Record a heartbeat for the authenticated user.
-
-    Sets a Redis key with a TTL so the server can derive online/offline
-    status without trusting client claims.  Also persists last_seen_at to
-    the database.
-    """
-    # Update Redis TTL (presence heartbeat)
-    await _presence_store.heartbeat(current_user.id)
-
-    # Persist last_seen_at to the database
-    now = datetime.now(timezone.utc)
-    result = await db.execute(
-        select(User).where(User.id == current_user.id)
-    )
-    user = result.scalar_one_or_none()
-    if user:
-        user.last_seen_at = now
-        await db.commit()
-
-    return {"status": "ok", "user_id": current_user.id}
-
-
-@router.get("/presence", response_model=PresenceResponse)
-async def get_presence(
-    user_ids: str,
-    current_user: CurrentUser,
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    """Return presence info for a comma-separated list of user ids.
-
-    Online/offline is derived from the Redis heartbeat TTL.
-    last_seen_at and status_message come from the database.
-    """
-    ids = [int(uid.strip()) for uid in user_ids.split(",") if uid.strip()]
-    if not ids:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="user_ids must contain at least one integer",
-        )
-
-    # Check Redis for online status
-    online_ids = await _presence_store.is_online_batch(ids)
-
-    # Fetch DB records for last_seen_at and status_message
-    result = await db.execute(
-        select(User).where(User.id.in_(ids))
-    )
-    users = {u.id: u for u in result.scalars().all()}
-
-    presence_users = []
-    for uid in ids:
-        user = users.get(uid)
-        if user is None:
-            continue
-        presence_users.append(
-            PresenceUser(
-                user_id=uid,
-                is_online=uid in online_ids,
-                last_seen_at=user.last_seen_at,
-                status_message=user.status_message,
-            )
-        )
-
-    return PresenceResponse(users=presence_users)
-
-
-@router.patch("/status", response_model=dict)
-async def update_status(
-    body: StatusUpdate,
-    current_user: CurrentUser,
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    """Update the authenticated user's status message (length-limited)."""
-    result = await db.execute(
-        select(User).where(User.id == current_user.id)
-    )
-    user = result.scalar_one_or_none()
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="User not found",
-        )
-
-    user.status_message = body.status_message
-    await db.commit()
-
-    return {"status": "ok", "status_message": body.status_message}

backend/app/services/presence.py

@@ -1,196 +0,0 @@
-"""Redis-backed presence store.
-
-Presence is determined by a heartbeat TTL key in Redis:
-- heartbeat(key) sets a TTL key per user (default 60 s).
-- is_online(user_id) checks whether the key exists.
-- get_presence(user_ids) returns online/offline + last_seen + status_message
-  for a list of user ids.
-
-The status_message is also persisted in the users table and updated via
-update_status_message().
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import datetime, timezone
-from typing import Any
-
-import redis.asyncio as aioredis
-
-from app.config import settings
-
-logger = logging.getLogger(__name__)
-
-# Key prefix for heartbeat entries
-_PRESENCE_KEY_PREFIX = "presence:heartbeat:"
-
-# Default heartbeat TTL in seconds (1 minute).
-# Clients should heartbeat at least once per interval.
-_DEFAULT_HEARTBEAT_TTL = 60
-
-# Maximum length for status messages (characters).
-_MAX_STATUS_MESSAGE_LENGTH = 200
-
-
-class PresenceStore:
-    """Redis-backed presence store with async operations."""
-
-    def __init__(self, redis_url: str = settings.REDIS_URL, heartbeat_ttl: int = _DEFAULT_HEARTBEAT_TTL):
-        self._redis_url = redis_url
-        self._heartbeat_ttl = heartbeat_ttl
-        self._client: aioredis.Redis | None = None
-
-    # ------------------------------------------------------------------
-    # Lifecycle
-    # ------------------------------------------------------------------
-
-    async def connect(self) -> None:
-        """Connect to Redis."""
-        self._client = aioredis.from_url(
-            self._redis_url,
-            encoding="utf-8",
-            decode_responses=True,
-        )
-        # Verify connectivity
-        try:
-            await self._client.ping()
-        except Exception as exc:
-            logger.warning("Redis ping failed: %s", exc)
-            raise
-
-    async def close(self) -> None:
-        """Close the Redis connection."""
-        if self._client is not None:
-            await self._client.close()
-            self._client = None
-
-    @property
-    def client(self) -> aioredis.Redis:
-        """Return the Redis client, raising if not connected."""
-        if self._client is None:
-            raise RuntimeError("PresenceStore is not connected. Call connect() first.")
-        return self._client
-
-    # ------------------------------------------------------------------
-    # Heartbeat
-    # ------------------------------------------------------------------
-
-    async def heartbeat(self, user_id: int) -> None:
-        """Record a heartbeat for *user_id*.
-
-        Sets a TTL key so that the user is considered online as long as
-        heartbeats arrive at least once per heartbeat_ttl seconds.
-        """
-        key = self._heartbeat_key(user_id)
-        await self.client.set(key, "1", ex=self._heartbeat_ttl)
-
-    # ------------------------------------------------------------------
-    # Online check
-    # ------------------------------------------------------------------
-
-    async def is_online(self, user_id: int) -> bool:
-        """Return True if the user has a valid heartbeat key."""
-        key = self._heartbeat_key(user_id)
-        exists = await self.client.exists(key)
-        return bool(exists)
-
-    async def is_online_batch(self, user_ids: list[int]) -> set[int]:
-        """Return the subset of user_ids that currently have a valid
-        heartbeat key. Uses MGET (one round trip) rather than one EXISTS
-        per user."""
-        if not user_ids:
-            return set()
-        keys = [self._heartbeat_key(uid) for uid in user_ids]
-        values = await self.client.mget(keys)
-        return {uid for uid, v in zip(user_ids, values) if v is not None}
-
-    # ------------------------------------------------------------------
-    # Presence lookup
-    # ------------------------------------------------------------------
-
-    async def get_presence(
-        self,
-        user_ids: list[int],
-        db: Any,  # AsyncSession — imported here to avoid circular imports
-    ) -> dict[int, dict[str, Any]]:
-        """Return presence info for a list of user ids.
-
-        Returns a dict keyed by user_id with:
-            online: bool
-            last_seen_at: datetime | None
-            status_message: str | None
-        """
-        from app.models.user import User
-        from sqlalchemy import select
-
-        result = await db.execute(select(User).where(User.id.in_(user_ids)))
-        users = result.scalars().all()
-        user_map = {u.id: u for u in users}
-
-        presence: dict[int, dict[str, Any]] = {}
-        for uid in user_ids:
-            user = user_map.get(uid)
-            online = await self.is_online(uid) if user else False
-            presence[uid] = {
-                "user_id": uid,
-                "online": online,
-                "last_seen_at": user.last_seen_at if user else None,
-                "status_message": user.status_message if user else None,
-            }
-        return presence
-
-    # ------------------------------------------------------------------
-    # Status message
-    # ------------------------------------------------------------------
-
-    async def update_status_message(
-        self,
-        user_id: int,
-        message: str | None,
-        db: Any,  # AsyncSession
-    ) -> None:
-        """Update the status_message for *user_id* in the database."""
-        from app.models.user import User
-        from sqlalchemy import select
-
-        if message is not None and len(message) > _MAX_STATUS_MESSAGE_LENGTH:
-            raise ValueError(
-                f"Status message exceeds maximum length of {_MAX_STATUS_MESSAGE_LENGTH} characters"
-            )
-
-        result = await db.execute(select(User).where(User.id == user_id))
-        user = result.scalar_one_or_none()
-        if user is None:
-            raise ValueError(f"User {user_id} not found")
-
-        user.status_message = message
-        user.last_seen_at = datetime.now(timezone.utc)
-        await db.commit()
-
-    # ------------------------------------------------------------------
-    # Helpers
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _heartbeat_key(user_id: int) -> str:
-        return f"{_PRESENCE_KEY_PREFIX}{user_id}"
-
-
-# Singleton instance — initialised by the lifespan handler
-presence_store: PresenceStore | None = None
-
-
-async def init_presence_store() -> None:
-    """Create and connect the global presence store."""
-    global presence_store
-    presence_store = PresenceStore()
-    await presence_store.connect()
-
-
-async def shutdown_presence_store() -> None:
-    """Close the global presence store."""
-    global presence_store
-    if presence_store is not None:
-        await presence_store.close()
-        presence_store = None

backend/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+asyncio_mode = auto
+testpaths = tests

backend/tests/test_auth_age_gate.py

@@ -0,0 +1,94 @@
+"""Tests for the 18+ age gate on user registration."""
+
+from datetime import date, timedelta
+
+import pytest
+
+from app.routers.auth import calculate_age
+
+
+class TestCalculateAge:
+    """Unit tests for the calculate_age helper."""
+
+    def test_exactly_18(self):
+        """A person born exactly 18 years ago today is 18."""
+        today = date(2025, 6, 15)
+        dob = today.replace(year=today.year - 18)
+        assert calculate_age(dob, today=today) == 18
+
+    def test_just_turned_18(self):
+        """A person who turned 18 yesterday is 18."""
+        today = date(2025, 6, 15)
+        dob = today.replace(year=today.year - 18) - timedelta(days=1)
+        assert calculate_age(dob, today=today) == 18
+
+    def test_one_day_short_of_18(self):
+        """A person born one day after their 18th birthday is 17."""
+        today = date(2025, 6, 15)
+        dob = today.replace(year=today.year - 18) + timedelta(days=1)
+        assert calculate_age(dob, today=today) == 17
+
+    def test_17_years_old(self):
+        """A person who is 17 years old today is 17."""
+        today = date(2025, 6, 15)
+        dob = date(2008, 6, 15)
+        assert calculate_age(dob, today=today) == 17
+
+    def test_65_years_old(self):
+        """A person who is 65 is correctly calculated."""
+        today = date(2025, 6, 15)
+        dob = today.replace(year=today.year - 65)
+        assert calculate_age(dob, today=today) == 65
+
+    def test_newborn(self):
+        """A newborn is 0."""
+        today = date(2025, 6, 15)
+        dob = today
+        assert calculate_age(dob, today=today) == 0
+
+    def test_birthday_not_yet_this_year(self):
+        """Person born Dec 31, 2000 — on Jan 1, 2025 they are still 24."""
+        dob = date(2000, 12, 31)
+        assert calculate_age(dob, today=date(2025, 1, 1)) == 24
+
+    def test_birthday_today(self):
+        """Person born Dec 31, 2000 — on Dec 31, 2024 they turn 24."""
+        dob = date(2000, 12, 31)
+        assert calculate_age(dob, today=date(2024, 12, 31)) == 24
+
+
+class TestRegisterRequestDateValidation:
+    """Tests for the RegisterRequest date_of_birth field validator."""
+
+    @pytest.mark.parametrize(
+        "dob",
+        [
+            "2000-01-01",
+            "1990-12-31",
+            "2004-02-29",  # leap day
+        ],
+    )
+    def test_valid_dates(self, dob):
+        """Valid YYYY-MM-DD dates pass validation."""
+        from app.routers.auth import RegisterRequest
+
+        req = RegisterRequest(username="u", email="u@example.com", password="p", date_of_birth=dob)
+        assert req.date_of_birth == dob
+
+    @pytest.mark.parametrize(
+        "dob",
+        [
+            "01-01-2000",
+            "2000/01/01",
+            "2000-13-01",
+            "2000-00-10",
+            "not-a-date",
+            "",
+        ],
+    )
+    def test_invalid_dates_rejected(self, dob):
+        """Invalid dates are rejected by the validator."""
+        from app.routers.auth import RegisterRequest
+
+        with pytest.raises(ValueError):
+            RegisterRequest(username="u", email="u@example.com", password="p", date_of_birth=dob)