Add: SuperAdmin create author endpoint (POST /api/super/authors) with optional plan + fix register ValueError 500

app/api/schemas_router.py

@@ -38,11 +38,15 @@ def _set_refresh_cookie(response: Response, refresh_token: str) -> None:
 @router.post("/auth/register", response_model=TokenResponse, status_code=201, tags=["Auth"])
 async def register(payload: RegisterRequest, response: Response, db: AsyncSession = Depends(get_db)):
     """Register a new author account."""
-    result = await AuthService(db).register(
-        email=payload.email,
-        password=payload.password,
-        full_name=payload.full_name,
-    )
+    from fastapi import HTTPException
+    try:
+        result = await AuthService(db).register(
+            email=payload.email,
+            password=payload.password,
+            full_name=payload.full_name,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
     _set_refresh_cookie(response, result["refresh_token"])
     return result
 

app/schemas/superadmin.py

@@ -3,7 +3,30 @@
 from datetime import datetime
 from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, EmailStr, Field, field_validator
+
+
+class CreateAuthorRequest(BaseModel):
+    """Request body for SuperAdmin to create a new author account."""
+
+    email: EmailStr
+    password: str = Field(..., min_length=8, max_length=128)
+    full_name: str = Field(..., min_length=1, max_length=255)
+    plan: Literal["monthly", "quarterly", "semi_annual", "annual"] | None = None
+    auto_renew: bool = False
+
+    @field_validator("password")
+    @classmethod
+    def password_complexity(cls, v: str) -> str:
+        if not any(c.isupper() for c in v):
+            raise ValueError("Password must contain at least one uppercase letter")
+        if not any(c.islower() for c in v):
+            raise ValueError("Password must contain at least one lowercase letter")
+        if not any(c.isdigit() for c in v):
+            raise ValueError("Password must contain at least one digit")
+        if not any(c in "!@#$%^&*()_+-=[]{}|;':\",./<>?" for c in v):
+            raise ValueError("Password must contain at least one special character")
+        return v
 
 
 class GrantAccessRequest(BaseModel):

app/superadmin/router.py

@@ -28,6 +28,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.dependencies import get_db, get_current_superadmin, get_redis
 from app.schemas.superadmin import (
+    CreateAuthorRequest,
     GrantAccessRequest, RevokeAccessRequest,
     AddBonusTokensRequest, ExtendSubscriptionRequest,
     ClientListResponse, ClientDetailResponse,
@@ -81,6 +82,65 @@ async def diagnostic(superadmin=Depends(get_current_superadmin)):
 
 # ── Authors ───────────────────────────────────────────────────────────────────
 
+@router.post("/authors", status_code=201)
+async def create_author(
+    payload: CreateAuthorRequest,
+    superadmin=Depends(get_current_superadmin),
+    db: AsyncSession = Depends(get_db),
+    redis=Depends(get_redis),
+):
+    """Create a new author account. Optionally assign a subscription plan."""
+    try:
+        from app.services.auth_service import AuthService
+
+        # Register the author
+        auth_svc = AuthService(db)
+        result = await auth_svc.register(
+            email=payload.email,
+            password=payload.password,
+            full_name=payload.full_name,
+        )
+        author_id = result["author_slug"]
+
+        # Log audit
+        from app.repositories.audit_repo import AuditRepository
+        audit = AuditRepository(db)
+        await audit.log(
+            actor_id=superadmin.id,
+            actor_email=superadmin.email,
+            action="create_author",
+            target_type="user",
+            target_id=author_id,
+            details=f"Created author {payload.email}",
+        )
+
+        response = {
+            "message": f"Author '{payload.full_name}' created successfully",
+            "author_id": author_id,
+            "email": payload.email,
+        }
+
+        # If plan specified, grant subscription immediately
+        if payload.plan:
+            service = SuperAdminService(db, redis)
+            grant_result = await service.grant_access(
+                actor=superadmin,
+                author_id=author_id,
+                plan=payload.plan,
+                auto_renew=payload.auto_renew,
+            )
+            response["subscription"] = {
+                "plan": payload.plan,
+                "token": grant_result.get("token"),
+                "expires_at": str(grant_result.get("expires_at", "")),
+            }
+
+        return response
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        return _err(e, "create_author")
+
 @router.get("/authors")
 async def list_authors(
     limit: int = Query(50, ge=1, le=500),