from __future__ import annotations
from datetime import timedelta
from typing import Any
from gnexus_gauth.config import GAuthConfig
from gnexus_gauth.dto import AuthenticatedUser, WebhookEvent
from gnexus_gauth.oauth import AuthorizationUrlBuilder, HttpTokenEndpoint, PkceGenerator
from gnexus_gauth.runtime import HttpRuntimeUserProvider
from gnexus_gauth.webhook import HmacWebhookVerifier, JsonWebhookParser
from ..config import Settings
from ..storage.db import Database
from ..storage.models import OAuthState, utcnow
from .sessions import CurrentUser, create_session, token_hash
from .users import upsert_user_from_auth
class AuthError(ValueError):
pass
class AuthService:
def __init__(self, settings: Settings, database: Database) -> None:
if not settings.auth_enabled:
raise AuthError("Authentication is not configured")
self.settings = settings
self.database = database
self.config = GAuthConfig(
base_url=settings.auth_base_url or "",
client_id=settings.auth_client_id or "",
client_secret=settings.auth_client_secret or "",
redirect_uri=settings.auth_redirect_uri or "",
state_ttl_seconds=settings.auth_state_ttl_seconds,
webhook_tolerance_seconds=settings.auth_webhook_tolerance_seconds,
user_agent="gnexus-book",
)
self._tokens = HttpTokenEndpoint(self.config)
self._users = HttpRuntimeUserProvider(self.config)
self._urls = AuthorizationUrlBuilder(self.config)
self._webhook_verifier = HmacWebhookVerifier(self.config)
self._webhook_parser = JsonWebhookParser()
def build_login_url(self, return_to: str | None = None) -> tuple[str, str]:
state = PkceGenerator.generate_state()
verifier = PkceGenerator.generate_verifier()
challenge = PkceGenerator.generate_challenge(verifier)
now = utcnow()
expires_at = now + timedelta(seconds=self.settings.auth_state_ttl_seconds)
with self.database.session() as session:
with session.begin():
session.add(
OAuthState(
state_hash=token_hash(state),
code_verifier=verifier,
return_to=return_to,
created_at=now,
expires_at=expires_at,
)
)
url = self._urls.build(
state=state,
pkce_challenge=challenge,
return_to=return_to,
scopes=list(self.settings.auth_scopes),
)
return url, state
def exchange_code(
self,
code: str,
state: str,
user_agent: str | None = None,
ip_address: str | None = None,
) -> tuple[CurrentUser, str, Any, str | None]:
now = utcnow()
state_hash = token_hash(state)
with self.database.session() as session:
record = session.get(OAuthState, state_hash)
if record is None or record.expires_at <= now:
raise AuthError("Unknown or expired authorization state")
verifier = record.code_verifier
return_to = record.return_to
if not verifier:
raise AuthError("Missing PKCE verifier")
token_set = self._tokens.exchange_authorization_code(code, verifier)
auth_user: AuthenticatedUser = self._users.fetch_user(token_set.access_token)
user = upsert_user_from_auth(
self.database, auth_user, self.settings.auth_client_id or ""
)
with self.database.session() as session:
with session.begin():
record = session.get(OAuthState, state_hash)
if record is not None:
session.delete(record)
token, expires_at = create_session(
self.database,
user.id,
self.settings.auth_session_ttl_seconds,
user_agent=user_agent,
ip_address=ip_address,
)
return user, token, expires_at, return_to
def verify_and_parse_webhook(
self, raw_body: str, headers: dict[str, str]
) -> WebhookEvent:
if not self.settings.auth_webhook_secret:
raise AuthError("Webhook secret is not configured")
self._webhook_verifier.verify(
raw_body, headers, self.settings.auth_webhook_secret
)
return self._webhook_parser.parse(raw_body)