docs: MVP vertical slice planning doc for client-server wiring

- Architecture task: ApiClient autoload (HTTP + JWT + error contract) - Implementation task: Login/Register UI wired to /api/auth - Implementation task: Browse worlds screen wired to GET /api/worlds - Validation task: End-to-end smoke test (login + list worlds)
Merge pull request 'Fix migration 0001_initial double CREATE TYPE + port collision' (#25 ) from fix/migration-0001-double-enum-and-port-collision into main
2026-08-19 12:39:33 +00:00 · 2026-08-18 21:57:01 +00:00 · 2026-08-18 21:55:34 +00:00
9 changed files with 45 additions and 365 deletions
@@ -8,7 +8,7 @@ from sqlalchemy.ext.asyncio import create_async_engine
 from app.config import settings
 from app.database import Base
-from app.models import user, session, world, asset, report, moderation_action, appeal  # noqa: F401
+from app.models import user, session, world, asset  # noqa: F401
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
@@ -69,7 +69,8 @@ def upgrade() -> None:
        sa.Column(
            "visibility",
            postgresql.ENUM(
-                "public", "private", "friends_only", name="world_visibility"
+                "public", "private", "friends_only", name="world_visibility",
                create_type=False,
            ),
            nullable=True,
        ),
@@ -89,7 +90,7 @@ def upgrade() -> None:
            "asset_type",
            postgresql.ENUM(
                "image", "audio", "video", "document", "model_3d", "other",
-                name="asset_type",
+                name="asset_type", create_type=False,
            ),
            nullable=False,
        ),
@@ -2,8 +2,5 @@ from app.models.user import User
 from app.models.session import Session
 from app.models.world import World
 from app.models.asset import Asset
 from app.models.report import Report
 from app.models.moderation_action import ModerationAction
 from app.models.appeal import Appeal
-__all__ = ["User", "Session", "World", "Asset", "Report", "ModerationAction", "Appeal"]
+__all__ = ["User", "Session", "World", "Asset"]
@@ -1,67 +0,0 @@
 """Appeal model for moderation actions."""
 from datetime import datetime
 from typing import Optional
 from sqlalchemy import (
    Column,
    Enum,
    ForeignKey,
    Integer,
    String,
    Text,
    DateTime,
    CheckConstraint,
 )
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.database import Base
 class Appeal(Base):
    __tablename__ = "appeals"
    id = Column(Integer, primary_key=True, index=True)
    moderation_action_id = Column(
        Integer,
        ForeignKey("moderation_actions.id", ondelete="CASCADE"),
        nullable=False,
    )
    user_id = Column(
        Integer,
        ForeignKey("users.id", ondelete="CASCADE"),
        nullable=False,
    )
    reason = Column(Text, nullable=False)
    status = Column(
        Enum("pending", "approved", "rejected", name="appeal_status", create_type=False),
        nullable=False,
        default="pending",
    )
    reviewed_by = Column(
        Integer,
        ForeignKey("users.id", ondelete="SET NULL"),
        nullable=True,
    )
    reviewed_at = Column(DateTime(timezone=True), nullable=True)
    created_at = Column(
        DateTime(timezone=True),
        server_default=func.now(),
        nullable=False,
    )
    # Relationships
    moderation_action = relationship("ModerationAction", back_populates="appeals")
    reviewer = relationship(
        "User",
        foreign_keys=[reviewed_by],
        back_populates="reviewed_appeals",
    )
    __table_args__ = (
        CheckConstraint(
            "status IN ('pending', 'approved', 'rejected')",
            name="check_appeal_status",
        ),
    )
@@ -1,118 +0,0 @@
 """Moderation action model."""
 from datetime import datetime
 from enum import Enum as PyEnum
 from typing import Optional
 from sqlalchemy import (
    Column,
    Enum,
    ForeignKey,
    Integer,
    String,
    Text,
    DateTime,
    func,
 )
 from sqlalchemy.dialects.postgresql import TIMESTAMPTZ
 from sqlalchemy.orm import relationship
 from app.database import Base
 class TargetType(str, PyEnum):
    """Type of entity being reported or moderated."""
    USER = "user"
    WORLD = "world"
    ASSET = "asset"
    CHAT_MESSAGE = "chat_message"
 class ReasonCategory(str, PyEnum):
    """Category of report reason."""
    HARASSMENT = "harassment"
    HATE_SPEECH = "hate_speech"
    SEXUAL_CONTENT = "sexual_content"
    VIOLENCE = "violence"
    SPAM = "spam"
    SELF_HARM = "self_harm"
    OTHER = "other"
 class ReportStatus(str, PyEnum):
    """Status of a report."""
    OPEN = "open"
    IN_REVIEW = "in_review"
    RESOLVED = "resolved"
    DISMISSED = "dismissed"
 class Resolution(str, PyEnum):
    """Resolution outcome of a report."""
    ACTION_TAKEN = "action_taken"
    NO_ACTION = "no_action"
 class ModerationActionType(str, PyEnum):
    """Type of moderation action."""
    WARN = "warn"
    SUSPEND = "suspend"
    BAN = "ban"
    RESTRICT = "restrict"
    REMOVE = "remove"
    RESTORE = "restore"
 class ModerationAction(Base):
    __tablename__ = "moderation_actions"
    id = Column(Integer, primary_key=True, index=True)
    moderator_id = Column(
        Integer,
        ForeignKey("users.id", ondelete="SET NULL"),
        nullable=True,
    )
    target_user_id = Column(
        Integer,
        ForeignKey("users.id", ondelete="SET NULL"),
        nullable=True,
    )
    target_type = Column(
        Enum(TargetType, name="target_type_enum", create_type=False),
        nullable=False,
    )
    target_id = Column(String(64), nullable=False)
    action = Column(
        Enum(ModerationActionType, name="moderation_action_type_enum", create_type=False),
        nullable=False,
    )
    reason = Column(Text, nullable=True)
    report_id = Column(
        Integer,
        ForeignKey("reports.id", ondelete="SET NULL"),
        nullable=True,
    )
    expires_at = Column(TIMESTAMPTZ, nullable=True)
    revoked_at = Column(TIMESTAMPTZ, nullable=True)
    created_at = Column(
        DateTime(timezone=True),
        server_default=func.now(),
    )
    # Relationships
    moderator = relationship(
        "User",
        foreign_keys=[moderator_id],
        back_populates="moderation_actions_given",
    )
    target_user = relationship(
        "User",
        foreign_keys=[target_user_id],
        back_populates="moderation_actions_received",
    )
    report = relationship("Report", back_populates="moderation_actions")
    appeals = relationship(
        "Appeal",
        back_populates="moderation_action",
        cascade="all, delete-orphan",
    )
@@ -1,146 +0,0 @@
 """Report model for user-generated moderation reports."""
 from datetime import datetime
 from typing import Optional
 import sqlalchemy as sa
 from sqlalchemy import (
    Column,
    DateTime,
    Enum,
    ForeignKey,
    Integer,
    String,
    Text,
 )
 from sqlalchemy.dialects.postgresql import TIMESTAMPTZ
 from sqlalchemy.orm import relationship
 from app.database import Base
 class ReportStatus:
    """Valid statuses for a Report."""
    OPEN = "open"
    IN_REVIEW = "in_review"
    RESOLVED = "resolved"
    DISMISSED = "dismissed"
 class Resolution:
    """Possible resolution outcomes for a Report."""
    ACTION_TAKEN = "action_taken"
    NO_ACTION = "no_action"
 class TargetType:
    """Types of entities that can be reported."""
    USER = "user"
    WORLD = "world"
    ASSET = "asset"
    CHAT_MESSAGE = "chat_message"
 class ReasonCategory:
    """Categories for why something was reported."""
    HARASSMENT = "harassment"
    HATE_SPEECH = "hate_speech"
    SEXUAL_CONTENT = "sexual_content"
    VIOLENCE = "violence"
    SPAM = "spam"
    SELF_HARM = "self_harm"
    OTHER = "other"
 class Report(Base):
    __tablename__ = "reports"
    id = Column(Integer, primary_key=True, index=True)
    reporter_id = Column(
        Integer,
        ForeignKey("users.id", ondelete="CASCADE"),
        nullable=False,
    )
    target_type = Column(
        Enum(
            TargetType.USER,
            TargetType.WORLD,
            TargetType.ASSET,
            TargetType.CHAT_MESSAGE,
            name="target_type",
            create_type=False,
        ),
        nullable=False,
    )
    target_id = Column(String(64), nullable=False)
    reason_category = Column(
        Enum(
            ReasonCategory.HARASSMENT,
            ReasonCategory.HATE_SPEECH,
            ReasonCategory.SEXUAL_CONTENT,
            ReasonCategory.VIOLENCE,
            ReasonCategory.SPAM,
            ReasonCategory.SELF_HARM,
            ReasonCategory.OTHER,
            name="reason_category",
            create_type=False,
        ),
        nullable=False,
    )
    details = Column(Text, nullable=True)
    status = Column(
        Enum(
            ReportStatus.OPEN,
            ReportStatus.IN_REVIEW,
            ReportStatus.RESOLVED,
            ReportStatus.DISMISSED,
            name="report_status",
            create_type=False,
        ),
        nullable=False,
        default=ReportStatus.OPEN,
    )
    resolved_by = Column(
        Integer,
        ForeignKey("users.id", ondelete="SET NULL"),
        nullable=True,
    )
    resolution = Column(
        Enum(
            Resolution.ACTION_TAKEN,
            Resolution.NO_ACTION,
            name="resolution",
            create_type=False,
        ),
        nullable=True,
    )
    created_at = Column(
        TIMESTAMPTZ,
        nullable=False,
        server_default=sa.func.now(),
    )
    updated_at = Column(
        TIMESTAMPTZ,
        nullable=False,
        server_default=sa.func.now(),
        onupdate=sa.func.now(),
    )
    resolved_at = Column(TIMESTAMPTZ, nullable=True)
    # Relationships
    reporter = relationship("User", foreign_keys=[reporter_id])
    resolver = relationship("User", foreign_keys=[resolved_by])
    moderation_actions = relationship(
        "ModerationAction",
        back_populates="report",
        cascade="all, delete-orphan",
    )
    appeals = relationship(
        "Appeal",
        back_populates="report",
        cascade="all, delete-orphan",
    )
@@ -1,20 +1,13 @@
 from datetime import date
 from typing import Optional
-from sqlalchemy import Column, Integer, String, Boolean, DateTime, Date, Enum
+from sqlalchemy import Column, Integer, String, Boolean, DateTime, Date
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.database import Base
 class UserRole:
    """Valid user roles."""
    USER = "user"
    MODERATOR = "moderator"
    ADMIN = "admin"
 class User(Base):
    __tablename__ = "users"
@@ -24,29 +17,12 @@ class User(Base):
    hashed_password = Column(String(255), nullable=False)
    date_of_birth = Column(Date, nullable=True)
    is_active = Column(Boolean, default=True)
    role = Column(
        Enum(UserRole.USER, UserRole.MODERATOR, UserRole.ADMIN, name="user_role", create_type=False),
        nullable=False,
        default=UserRole.USER,
    )
    banned_until = Column(DateTime(timezone=True), nullable=True)
    suspended_until = Column(DateTime(timezone=True), nullable=True)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan")
    worlds = relationship("World", back_populates="owner")
    assets = relationship("Asset", back_populates="owner")
    moderation_actions_given = relationship(
        "ModerationAction",
        foreign_keys="ModerationAction.moderator_id",
        back_populates="moderator",
    )
    moderation_actions_received = relationship(
        "ModerationAction",
        foreign_keys="ModerationAction.target_user_id",
        back_populates="target_user",
    )
    @property
    def is_adult(self) -> bool:
@@ -8,7 +8,7 @@ services:
      POSTGRES_PASSWORD: agp_password
      POSTGRES_DB: agp_db
    ports:
-      - "5432:5432"
+      - "${POSTGRES_HOST_PORT:-5432}:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
@@ -20,7 +20,7 @@ services:
  redis:
    image: redis:7-alpine
    ports:
-      - "6379:6379"
+      - "${REDIS_HOST_PORT:-6379}:6379"
    volumes:
      - redis_data:/data
    healthcheck:
@@ -0,0 +1,37 @@
 # MVP Vertical Slice: Client-Server Wiring — Plan
 ## Goal
 Prove the real Godot client and the real backend can talk: **a user can register/log in
 and see a list of worlds from the game client**. Nothing more. Gameplay, join-a-world,
 chat, avatar, Discovery search/tags/trending, Social/Economy/Trust & Safety are all
 explicitly out of scope.
 ## Verified backend contract (as of this writing)
 - `POST /api/auth/register` — JSON body `{username, email, password, date_of_birth}`.
  `date_of_birth` is a `YYYY-MM-DD` string. Returns `201 {access_token, token_type}`.
  Rejects under-18 with `400`.
 - `POST /api/auth/login` — OAuth2 **form-encoded** (`application/x-www-form-urlencoded`)
  `username` + `password` (this is NOT a JSON endpoint). Returns `{access_token, token_type}`.
 - `GET /api/worlds` — **requires auth** (`CurrentUser`), returns a JSON array of
  `{id, name, description, visibility, owner_id, created_at}`. There is no unauthenticated
  public-worlds path, so the worlds list screen can only be shown after login/register.
 - `GET /api/health` — unauthenticated, `{status, app}`.
 - Base URL: uvicorn default `http://127.0.0.1:8000` (must be configurable in the client).
 - CORS is irrelevant to the native Godot `HTTPRequest` client (no browser origin).
 ## Task breakdown
 | # | Type | Task | Depends on |
 |---|------|------|-----------|
 | 1 | architecture | `ApiClient` autoload: HTTP + JWT storage + error contract | — |
 | 2 | implementation | Main-menu **login** wiring (form-encoded) | 1 |
 | 3 | implementation | Main-menu **register** wiring (JSON + age gate) | 2 |
 | 4 | implementation | **World list** screen consuming `GET /api/worlds` | 2 |
 | 5 | testing | End-to-end headless smoke test + manual verify | 1,3,4 |
 ## Design decisions captured (resolved in task 1)
 - Token storage: in-memory singleton property for the MVP; a `save_to_disk` seam is left
  open but not required yet (no re-login on restart in this slice).
 - Error contract: every call returns a discriminated result (`ok`/`error`) so callers
  never crash on network failure; non-2xx surfaces `{status, detail}` from the backend.
 - Base URL: read from a ProjectSetting, defaulting to `http://127.0.0.1:8000`.
 - Login is form-encoded; register is JSON — the client helper must support both content types.