File size: 5,388 Bytes
30a8511
 
 
 
 
 
 
 
 
 
 
8bd4797
30a8511
 
 
 
 
 
8bd4797
 
 
7d60e0f
30a8511
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
238042d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
30a8511
 
 
 
7d60e0f
238042d
30a8511
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7d60e0f
30a8511
238042d
30a8511
 
 
 
 
 
 
 
 
 
7d60e0f
30a8511
238042d
30a8511
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7d60e0f
30a8511
238042d
30a8511
 
 
 
7d60e0f
 
 
238042d
7d60e0f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
"""
Auth endpoints — signup, login, Google SSO, me.
Mirrored from NourishBot/routes/auth.py; adapted to CodyBuddy conventions.
"""
import os

from fastapi import APIRouter, Depends, HTTPException, status
from pydantic import BaseModel, EmailStr
from sqlalchemy.orm import Session

from auth.dependencies import get_current_user
from auth.roles import SUPER_ADMIN_EMAILS, ensure_role as _ensure_role, resolve_role as _resolve_role
from auth.utils import create_access_token, hash_password, verify_password
from db.database import get_db
from db.models import User

router = APIRouter(prefix="/auth", tags=["auth"])

# Role logic (allowlist) now lives in auth.roles so get_current_user can apply it
# on every authenticated request — re-exported here for the auth endpoints.
__all__ = ["router", "SUPER_ADMIN_EMAILS"]


class SignupRequest(BaseModel):
    email: EmailStr
    password: str
    name: str | None = None


class LoginRequest(BaseModel):
    email: EmailStr
    password: str


class GoogleAuthRequest(BaseModel):
    id_token: str


class GitHubStatus(BaseModel):
    connected: bool = False
    login: str | None = None


def _github_status(user: User) -> GitHubStatus:
    """Derive GitHub connection status defensively. NEVER returns the token.

    ponytail: guard against MagicMock/non-str attrs (test fixtures) — only a real,
    non-empty encrypted string counts as connected.
    """
    enc = getattr(user, "github_token_enc", None)
    login = getattr(user, "github_login", None)
    connected = isinstance(enc, str) and bool(enc)
    return GitHubStatus(connected=connected, login=login if (connected and isinstance(login, str)) else None)


class UserResponse(BaseModel):
    id: str
    email: str
    name: str | None
    role: str = "user"
    github: GitHubStatus = GitHubStatus()

    model_config = {"from_attributes": True}


class AuthResponse(BaseModel):
    token: str
    user: UserResponse


@router.post("/signup", response_model=AuthResponse, status_code=status.HTTP_201_CREATED)
def signup(payload: SignupRequest, db: Session = Depends(get_db)) -> AuthResponse:
    if len(payload.password) < 8:
        raise HTTPException(status_code=400, detail="Password must be at least 8 characters")
    if db.query(User).filter(User.email == payload.email).first():
        raise HTTPException(status_code=409, detail="Email already registered")

    user = User(
        email=payload.email,
        name=payload.name or payload.email.split("@")[0],
        hashed_password=hash_password(payload.password),
    )
    db.add(user)
    db.commit()
    db.refresh(user)

    role = _ensure_role(user, db)
    token = create_access_token(str(user.id), user.email)
    return AuthResponse(token=token, user=UserResponse(id=str(user.id), email=user.email, name=user.name, role=role, github=_github_status(user)))


@router.post("/login", response_model=AuthResponse)
def login(payload: LoginRequest, db: Session = Depends(get_db)) -> AuthResponse:
    user = db.query(User).filter(User.email == payload.email).first()
    if not user or not user.hashed_password:
        raise HTTPException(status_code=401, detail="Invalid credentials")
    if not verify_password(payload.password, user.hashed_password):
        raise HTTPException(status_code=401, detail="Invalid credentials")

    role = _ensure_role(user, db)
    token = create_access_token(str(user.id), user.email)
    return AuthResponse(token=token, user=UserResponse(id=str(user.id), email=user.email, name=user.name, role=role, github=_github_status(user)))


@router.post("/google", response_model=AuthResponse)
def google_auth(payload: GoogleAuthRequest, db: Session = Depends(get_db)) -> AuthResponse:
    google_client_id = os.environ.get("GOOGLE_CLIENT_ID", "")
    if not google_client_id:
        raise HTTPException(status_code=503, detail="Google sign-in not configured")

    from google.oauth2 import id_token as google_id_token
    from google.auth.transport import requests as google_requests

    try:
        idinfo = google_id_token.verify_oauth2_token(
            payload.id_token,
            google_requests.Request(),
            google_client_id,
        )
    except ValueError as exc:
        raise HTTPException(status_code=401, detail=f"Invalid Google token: {exc}")

    google_id = idinfo["sub"]
    email = idinfo["email"]
    name = idinfo.get("name", email.split("@")[0])

    # ponytail: upsert by google_id first, then email, then create
    user = db.query(User).filter(User.google_id == google_id).first()
    if not user:
        user = db.query(User).filter(User.email == email).first()
        if user:
            user.google_id = google_id
        else:
            user = User(email=email, name=name, google_id=google_id)
            db.add(user)
    db.commit()
    db.refresh(user)

    role = _ensure_role(user, db)
    token = create_access_token(str(user.id), user.email)
    return AuthResponse(token=token, user=UserResponse(id=str(user.id), email=user.email, name=user.name, role=role, github=_github_status(user)))


@router.get("/me", response_model=UserResponse)
def me(current_user: User = Depends(get_current_user)) -> UserResponse:
    return UserResponse(
        id=str(current_user.id), email=current_user.email,
        name=current_user.name, role=_resolve_role(current_user.email),
        github=_github_status(current_user),
    )