Step 12 - completed

app/api/routes/backup.py

@@ -1,7 +1,7 @@
 """Backup routes: upload, download, history, and delete E2E-encrypted backups.
 
-Blobs are stored in S3 via BlobStore. Backup metadata is kept in an
-in-memory dict until Step 12 migrates it to PostgreSQL (backup_metadata table).
+Blobs are stored in S3 via BlobStore. Backup metadata is persisted in the
+PostgreSQL ``backup_metadata`` table.
 
 IMPORTANT: GET /history must be declared BEFORE GET / to avoid FastAPI
 treating "history" as a ``{backup_id}`` path parameter.
@@ -9,14 +9,17 @@ treating "history" as a ``{backup_id}`` path parameter.
 
 from __future__ import annotations
 
-import time
+import uuid
 from email.utils import parsedate_to_datetime
-from typing import Any
 
 from fastapi import APIRouter, Depends, Header, HTTPException, Request, Response, status
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.deps import get_current_user
 from app.billing.tier_manager import tier_manager
+from app.db import get_session
+from app.models import BackupMetadata as BackupMetadataModel
 from app.schemas import BackupMetadata, UserProfile
 from app.storage.blob_store import BlobStore
 from app.storage.encryption import reject_if_tampered
@@ -25,14 +28,25 @@ router = APIRouter(prefix="/backup", tags=["backup"])
 
 _blob_store = BlobStore()
 
-# In-memory backup metadata — replaced by PostgreSQL backup_metadata table in Step 12
-_backups: dict[str, list[dict[str, Any]]] = {}  # user_id → list of backup records
+
+async def _current_backup_bytes(user_id: str, db: AsyncSession) -> int:
+    """Return total backup bytes stored by *user_id*."""
+    result = await db.execute(
+        select(func.coalesce(func.sum(BackupMetadataModel.size_bytes), 0)).where(
+            BackupMetadataModel.user_id == user_id
+        )
+    )
+    return int(result.scalar_one())
 
 
-def _check_backup_quota(user_id: str, size_bytes: int) -> None:
+async def _check_backup_quota(
+    user: UserProfile, size_bytes: int, db: AsyncSession
+) -> None:
     """Raise HTTP 402 if the upload would exceed the tier's backup limit."""
-    current = sum(b["size_bytes"] for b in _backups.get(user_id, []))
-    tier_manager.enforce_backup_quota(user_id, current_bytes=current, additional_bytes=size_bytes)
+    current = await _current_backup_bytes(user.id, db)
+    tier_manager.enforce_backup_quota(
+        user.tier, current_bytes=current, additional_bytes=size_bytes
+    )
 
 
 @router.put("")
@@ -42,6 +56,7 @@ async def upload_backup(
     x_backup_timestamp: int = Header(..., alias="X-Backup-Timestamp"),
     x_backup_checksum: str = Header(..., alias="X-Backup-Checksum"),
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> dict[str, bool]:
     """Upload an E2E-encrypted backup blob.
 
@@ -49,24 +64,23 @@ async def upload_backup(
     """
     blob = await request.body()
     reject_if_tampered(blob, x_backup_checksum)
-    _check_backup_quota(current_user.id, len(blob))
+    await _check_backup_quota(current_user, len(blob), db)
 
     s3_key = await _blob_store.upload(
         current_user.id, "backup", str(x_backup_timestamp), blob, x_backup_checksum
     )
 
-    backup_record: dict[str, Any] = {
-        "id": str(x_backup_timestamp),
-        "s3_key": s3_key,
-        "version": x_backup_version,
-        "timestamp": x_backup_timestamp,
-        "checksum": x_backup_checksum,
-        "size_bytes": len(blob),
-    }
-
-    user_backups = _backups.setdefault(current_user.id, [])
-    user_backups.append(backup_record)
-    user_backups.sort(key=lambda b: b["timestamp"], reverse=True)
+    row = BackupMetadataModel(
+        id=str(uuid.uuid4()),
+        user_id=current_user.id,
+        s3_key=s3_key,
+        version=x_backup_version,
+        timestamp=x_backup_timestamp,
+        checksum=x_backup_checksum,
+        size_bytes=len(blob),
+    )
+    db.add(row)
+    await db.commit()
 
     return {"ok": True}
 
@@ -74,16 +88,23 @@ async def upload_backup(
 @router.get("/history", response_model=list[BackupMetadata])
 async def backup_history(
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> list[BackupMetadata]:
     """Return backup metadata records for the authenticated user (no blob bytes)."""
+    result = await db.execute(
+        select(BackupMetadataModel)
+        .where(BackupMetadataModel.user_id == current_user.id)
+        .order_by(BackupMetadataModel.timestamp.desc())
+    )
+    rows = result.scalars().all()
     return [
         BackupMetadata(
-            version=b["version"],
-            timestamp=b["timestamp"],
-            checksum=b["checksum"],
-            chunk_count=1,  # single-chunk uploads for now — TODO(Step12): track real count
+            version=r.version,
+            timestamp=r.timestamp,
+            checksum=r.checksum,
+            chunk_count=1,
         )
-        for b in _backups.get(current_user.id, [])
+        for r in rows
     ]
 
 
@@ -91,32 +112,37 @@ async def backup_history(
 async def download_backup(
     request: Request,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> Response:
     """Download the latest backup blob. Supports ``If-Modified-Since``."""
-    user_backups = _backups.get(current_user.id, [])
-    if not user_backups:
+    result = await db.execute(
+        select(BackupMetadataModel)
+        .where(BackupMetadataModel.user_id == current_user.id)
+        .order_by(BackupMetadataModel.timestamp.desc())
+        .limit(1)
+    )
+    latest = result.scalar_one_or_none()
+    if latest is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="No backup found")
 
-    latest = user_backups[0]
-
     ims_header = request.headers.get("If-Modified-Since")
     if ims_header:
         try:
             ims_dt = parsedate_to_datetime(ims_header)
             ims_ms = int(ims_dt.timestamp() * 1000)
-            if latest["timestamp"] <= ims_ms:
+            if latest.timestamp <= ims_ms:
                 return Response(status_code=status.HTTP_304_NOT_MODIFIED)
         except Exception:
             pass  # malformed header — ignore and serve the blob
 
-    blob = await _blob_store.download(current_user.id, latest["s3_key"])
+    blob = await _blob_store.download(current_user.id, latest.s3_key)
     return Response(
         content=blob,
         media_type="application/octet-stream",
         headers={
-            "X-Backup-Version": str(latest["version"]),
-            "X-Backup-Timestamp": str(latest["timestamp"]),
-            "X-Checksum": latest["checksum"],
+            "X-Backup-Version": str(latest.version),
+            "X-Backup-Timestamp": str(latest.timestamp),
+            "X-Checksum": latest.checksum,
         },
     )
 
@@ -125,14 +151,21 @@ async def download_backup(
 async def delete_backup(
     backup_id: str,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> dict[str, bool]:
     """Delete a specific backup by ID."""
-    user_backups = _backups.get(current_user.id, [])
-    target = next((b for b in user_backups if b["id"] == backup_id), None)
+    result = await db.execute(
+        select(BackupMetadataModel).where(
+            BackupMetadataModel.id == backup_id,
+            BackupMetadataModel.user_id == current_user.id,
+        )
+    )
+    target = result.scalar_one_or_none()
     if target is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Backup not found")
 
-    await _blob_store.delete(current_user.id, target["s3_key"])
-    _backups[current_user.id] = [b for b in user_backups if b["id"] != backup_id]
+    await _blob_store.delete(current_user.id, target.s3_key)
+    await db.delete(target)
+    await db.commit()
 
     return {"ok": True}

app/api/routes/plugins.py

@@ -1,8 +1,7 @@
 """Plugins routes: browse and install plugins from the marketplace.
 
-Backed by ``PluginRegistry`` and ``RevenueShare`` service classes introduced
-in Step 10.  Step 12 will swap those services' in-memory stores for
-PostgreSQL persistence.
+Backed by ``PluginRegistry`` and ``RevenueShare`` service classes that
+persist data in the PostgreSQL ``plugins`` and ``revenue_events`` tables.
 """
 
 from __future__ import annotations
@@ -11,10 +10,14 @@ from typing import Any, Literal
 
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.deps import get_current_user
+from app.db import get_session
 from app.marketplace.plugin_registry import registry
 from app.marketplace.revenue_share import revenue_share
+from app.models import PluginInstallation, PluginReview as PluginReviewModel
 from app.schemas import PluginInstallRequest, PluginListResponse, PluginManifest, UserProfile
 
 router = APIRouter(prefix="/plugins", tags=["plugins"])
@@ -36,7 +39,7 @@ def _require_plugin_tier(user: UserProfile) -> None:
 class _PluginDetail(BaseModel):
     plugin: PluginManifest
     install_count: int
-    ratings: list[Any]  # Step 12 populates from plugin_reviews table
+    ratings: list[Any]
 
 
 # ── Routes ────────────────────────────────────────────────────────────
@@ -48,26 +51,44 @@ async def list_plugins(
     page: int = Query(default=1, ge=1),
     sort: Literal["rating", "installs", "newest"] = Query(default="newest"),
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> PluginListResponse:
     """Browse the plugin marketplace. Requires Power tier or above."""
     _require_plugin_tier(current_user)
-    return await registry.list_plugins(category=category, query=q, page=page, sort=sort)
+    return await registry.list_plugins(db, category=category, query=q, page=page, sort=sort)
 
 
 @router.get("/{plugin_id}", response_model=_PluginDetail)
 async def get_plugin(
     plugin_id: str,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> _PluginDetail:
     """Get full plugin details including install count. Requires Power tier or above."""
     _require_plugin_tier(current_user)
-    entry = await registry.get_plugin(plugin_id)
+    entry = await registry.get_plugin(db, plugin_id)
     if entry is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Plugin not found")
+
+    # Fetch review ratings for this plugin
+    review_result = await db.execute(
+        select(PluginReviewModel).where(PluginReviewModel.plugin_id == plugin_id)
+    )
+    reviews = review_result.scalars().all()
+    ratings = [
+        {
+            "reviewer_id": r.reviewer_id,
+            "decision": r.decision,
+            "notes": r.notes,
+            "reviewed_at": int(r.reviewed_at.timestamp() * 1000) if r.reviewed_at else None,
+        }
+        for r in reviews
+    ]
+
     return _PluginDetail(
         plugin=entry["manifest"],
         install_count=entry["install_count"],
-        ratings=[],  # Step 12 populates from plugin_reviews table
+        ratings=ratings,
     )
 
 
@@ -76,17 +97,27 @@ async def install_plugin(
     plugin_id: str,
     body: PluginInstallRequest,  # noqa: ARG001 — reserved for future fields
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> dict[str, Any]:
     """Install a plugin. Triggers Stripe Connect revenue split for paid plugins.
 
     Requires Power tier or above.
     """
     _require_plugin_tier(current_user)
-    entry = await registry.get_plugin(plugin_id)
+    entry = await registry.get_plugin(db, plugin_id)
     if entry is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Plugin not found")
 
+    # Record the installation in plugin_installations
+    installation = PluginInstallation(
+        plugin_id=plugin_id,
+        user_id=current_user.id,
+    )
+    db.add(installation)
+    await db.flush()
+
     await revenue_share.record_install(
+        db,
         plugin_id=plugin_id,
         user_id=current_user.id,
         amount_cents=entry["manifest"].price_cents,
@@ -100,7 +131,18 @@ async def install_plugin(
 async def uninstall_plugin(
     plugin_id: str,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> dict[str, bool]:
     """Unregister a plugin installation."""
-    await registry.record_uninstall(plugin_id)
+    result = await db.execute(
+        select(PluginInstallation).where(
+            PluginInstallation.plugin_id == plugin_id,
+            PluginInstallation.user_id == current_user.id,
+        )
+    )
+    installation = result.scalar_one_or_none()
+    if installation is not None:
+        await db.delete(installation)
+        await db.commit()
+    await registry.record_uninstall(db, plugin_id)
     return {"ok": True}

app/api/routes/storage.py

@@ -1,20 +1,23 @@
 """Storage routes: CRUD for E2E-encrypted cloud records.
 
-Blobs are stored in S3 via BlobStore. Record metadata is kept in an
-in-memory dict until Step 12 migrates it to PostgreSQL (storage_records table).
+Blobs are stored in S3 via BlobStore. Record metadata is persisted in the
+PostgreSQL ``storage_records`` table.
 """
 
 from __future__ import annotations
 
-import time
 import uuid
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
 from pydantic import BaseModel
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.deps import get_current_user
 from app.billing.tier_manager import tier_manager
+from app.db import get_session
+from app.models import StorageRecord
 from app.schemas import StorageRecordCreate, StorageRecordUpdate, UserProfile
 from app.storage.blob_store import BlobStore
 from app.storage.encryption import reject_if_tampered
@@ -23,9 +26,6 @@ router = APIRouter(prefix="/storage", tags=["storage"])
 
 _blob_store = BlobStore()
 
-# In-memory record metadata — replaced by PostgreSQL storage_records table in Step 12
-_records: dict[str, dict[str, Any]] = {}
-
 
 # ── Local response schemas ─────────────────────────────────────────────
 
@@ -44,17 +44,34 @@ class _RecordMeta(BaseModel):
 
 # ── Helpers ────────────────────────────────────────────────────────────
 
-def _check_quota(user_id: str, additional_bytes: int) -> None:
-    """Raise HTTP 402 if adding ``additional_bytes`` would exceed the tier limit."""
-    current = sum(r["size_bytes"] for r in _records.values() if r["user_id"] == user_id)
-    tier_manager.enforce_quota(user_id, current_bytes=current, additional_bytes=additional_bytes)
+async def _current_usage_bytes(user_id: str, db: AsyncSession) -> int:
+    """Return total bytes stored by *user_id*."""
+    result = await db.execute(
+        select(func.coalesce(func.sum(StorageRecord.size_bytes), 0)).where(
+            StorageRecord.user_id == user_id
+        )
+    )
+    return int(result.scalar_one())
 
 
-def _get_record_for_user(record_id: str, user_id: str) -> dict[str, Any]:
-    """Look up a record and verify ownership. Always returns 404 on mismatch
+async def _check_quota(user: UserProfile, additional_bytes: int, db: AsyncSession) -> None:
+    """Raise HTTP 402 if adding *additional_bytes* would exceed the tier limit."""
+    current = await _current_usage_bytes(user.id, db)
+    tier_manager.enforce_quota(user.tier, current_bytes=current, additional_bytes=additional_bytes)
+
+
+async def _get_record_for_user(
+    record_id: str, user_id: str, db: AsyncSession
+) -> StorageRecord:
+    """Look up a record and verify ownership. Returns 404 on mismatch
     to prevent user enumeration attacks."""
-    record = _records.get(record_id)
-    if record is None or record["user_id"] != user_id:
+    result = await db.execute(
+        select(StorageRecord).where(
+            StorageRecord.id == record_id, StorageRecord.user_id == user_id
+        )
+    )
+    record = result.scalar_one_or_none()
+    if record is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Record not found")
     return record
 
@@ -65,30 +82,32 @@ def _get_record_for_user(record_id: str, user_id: str) -> dict[str, Any]:
 async def create_record(
     body: StorageRecordCreate,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> _CreateResponse:
     """Upload a new E2E-encrypted blob. Verifies checksum before storing."""
     reject_if_tampered(body.blob, body.checksum)
-    _check_quota(current_user.id, len(body.blob))
+    await _check_quota(current_user, len(body.blob), db)
 
     record_id = str(uuid.uuid4())
-    now = int(time.time() * 1000)
 
     s3_key = await _blob_store.upload(
         current_user.id, body.table, record_id, body.blob, body.checksum
     )
 
-    _records[record_id] = {
-        "id": record_id,
-        "user_id": current_user.id,
-        "table": body.table,
-        "s3_key": s3_key,
-        "checksum": body.checksum,
-        "size_bytes": len(body.blob),
-        "created_at": now,
-        "updated_at": now,
-    }
+    record = StorageRecord(
+        id=record_id,
+        user_id=current_user.id,
+        table_name=body.table,
+        s3_key=s3_key,
+        checksum=body.checksum,
+        size_bytes=len(body.blob),
+    )
+    db.add(record)
+    await db.commit()
+    await db.refresh(record)
 
-    return _CreateResponse(id=record_id, created_at=now)
+    created_at_ms = int(record.created_at.timestamp() * 1000)
+    return _CreateResponse(id=record_id, created_at=created_at_ms)
 
 
 @router.get("/records", response_model=list[_RecordMeta])
@@ -97,23 +116,26 @@ async def list_records(
     page: int = Query(default=1, ge=1),
     limit: int = Query(default=50, ge=1, le=200),
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> list[_RecordMeta]:
     """List record metadata for the authenticated user. Blob bytes are never returned."""
-    all_records = [
-        r for r in _records.values()
-        if r["user_id"] == current_user.id and (table is None or r["table"] == table)
-    ]
-    start = (page - 1) * limit
-    page_records = all_records[start : start + limit]
+    query = select(StorageRecord).where(StorageRecord.user_id == current_user.id)
+    if table is not None:
+        query = query.where(StorageRecord.table_name == table)
+    query = query.offset((page - 1) * limit).limit(limit)
+
+    result = await db.execute(query)
+    rows = result.scalars().all()
+
     return [
         _RecordMeta(
-            id=r["id"],
-            table=r["table"],
-            checksum=r["checksum"],
-            created_at=r["created_at"],
-            updated_at=r["updated_at"],
+            id=r.id,
+            table=r.table_name,
+            checksum=r.checksum,
+            created_at=int(r.created_at.timestamp() * 1000),
+            updated_at=int(r.updated_at.timestamp() * 1000),
         )
-        for r in page_records
+        for r in rows
     ]
 
 
@@ -121,14 +143,15 @@ async def list_records(
 async def download_record(
     record_id: str,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> Response:
     """Download an E2E-encrypted blob. Returns raw bytes with ``X-Checksum`` header."""
-    record = _get_record_for_user(record_id, current_user.id)
-    blob = await _blob_store.download(current_user.id, record["s3_key"])
+    record = await _get_record_for_user(record_id, current_user.id, db)
+    blob = await _blob_store.download(current_user.id, record.s3_key)
     return Response(
         content=blob,
         media_type="application/octet-stream",
-        headers={"X-Checksum": record["checksum"]},
+        headers={"X-Checksum": record.checksum},
     )
 
 
@@ -137,23 +160,24 @@ async def update_record(
     record_id: str,
     body: StorageRecordUpdate,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> dict[str, bool]:
     """Replace the blob for an existing record. Verifies checksum before storing."""
-    record = _get_record_for_user(record_id, current_user.id)
+    record = await _get_record_for_user(record_id, current_user.id, db)
     reject_if_tampered(body.blob, body.checksum)
 
-    delta = len(body.blob) - record["size_bytes"]
+    delta = len(body.blob) - record.size_bytes
     if delta > 0:
-        _check_quota(current_user.id, delta)
+        await _check_quota(current_user, delta, db)
 
     s3_key = await _blob_store.upload(
-        current_user.id, record["table"], record_id, body.blob, body.checksum
+        current_user.id, record.table_name, record_id, body.blob, body.checksum
     )
 
-    record["s3_key"] = s3_key
-    record["checksum"] = body.checksum
-    record["size_bytes"] = len(body.blob)
-    record["updated_at"] = int(time.time() * 1000)
+    record.s3_key = s3_key
+    record.checksum = body.checksum
+    record.size_bytes = len(body.blob)
+    await db.commit()
 
     return {"ok": True}
 
@@ -162,9 +186,11 @@ async def update_record(
 async def delete_record(
     record_id: str,
     current_user: UserProfile = Depends(get_current_user),
+    db: AsyncSession = Depends(get_session),
 ) -> dict[str, bool]:
     """Delete a record and its S3 blob."""
-    record = _get_record_for_user(record_id, current_user.id)
-    await _blob_store.delete(current_user.id, record["s3_key"])
-    del _records[record_id]
+    record = await _get_record_for_user(record_id, current_user.id, db)
+    await _blob_store.delete(current_user.id, record.s3_key)
+    await db.delete(record)
+    await db.commit()
     return {"ok": True}