vibetuner 2.6.1__py3-none-any.whl → 2.7.1__py3-none-any.whl

vibetuner/frontend/__init__.py

@@ -0,0 +1,94 @@
+from typing import Any
+
+from fastapi import APIRouter, Depends as Depends, FastAPI, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+
+from vibetuner import paths
+
+from .deps import LangDep as LangDep, MagicCookieDep as MagicCookieDep
+from .lifespan import ctx, lifespan
+from .middleware import middlewares
+from .routes import auth, debug, health, language, meta, user
+from .templates import render_template
+
+
+_registered_routers: list[APIRouter] = []
+
+
+def register_router(router: APIRouter) -> None:
+    _registered_routers.append(router)
+
+
+try:
+    import app.frontend.oauth as _app_oauth  # noqa: F401
+    import app.frontend.routes as _app_routes  # noqa: F401
+except (ImportError, ModuleNotFoundError):
+    pass
+
+
+dependencies: list[Any] = [
+    # Add any dependencies that should be available globally
+]
+
+app = FastAPI(
+    debug=ctx.DEBUG,
+    lifespan=lifespan,
+    docs_url=None,
+    redoc_url=None,
+    openapi_url=None,
+    middleware=middlewares,
+    dependencies=dependencies,
+)
+
+# Static files
+app.mount(f"/static/v{ctx.v_hash}/css", StaticFiles(directory=paths.css), name="css")
+app.mount(f"/static/v{ctx.v_hash}/img", StaticFiles(directory=paths.img), name="img")
+app.mount(f"/static/v{ctx.v_hash}/js", StaticFiles(directory=paths.js), name="js")
+
+app.mount("/static/favicons", StaticFiles(directory=paths.favicons), name="favicons")
+
+
+@app.get("/static/v{v_hash}/css/{subpath:path}", response_class=RedirectResponse)
+@app.get("/static/css/{subpath:path}", response_class=RedirectResponse)
+def css_redirect(request: Request, subpath: str):
+    return request.url_for("css", path=subpath).path
+
+
+@app.get("/static/v{v_hash}/img/{subpath:path}", response_class=RedirectResponse)
+@app.get("/static/img/{subpath:path}", response_class=RedirectResponse)
+def img_redirect(request: Request, subpath: str):
+    return request.url_for("img", path=subpath).path
+
+
+@app.get("/static/v{v_hash}/js/{subpath:path}", response_class=RedirectResponse)
+@app.get("/static/js/{subpath:path}", response_class=RedirectResponse)
+def js_redirect(request: Request, subpath: str):
+    return request.url_for("js", path=subpath).path
+
+
+if ctx.DEBUG:
+    from .hotreload import hotreload
+
+    app.add_websocket_route(
+        "/hot-reload",
+        route=hotreload,  # type: ignore
+        name="hot-reload",
+    )
+
+app.include_router(meta.router)
+app.include_router(auth.router)
+app.include_router(user.router)
+app.include_router(language.router)
+
+for router in _registered_routers:
+    app.include_router(router)
+
+
+@app.get("/", name="homepage", response_class=HTMLResponse)
+def default_index(request: Request) -> HTMLResponse:
+    return render_template("index.html.jinja", request)
+
+
+app.include_router(debug.router)
+app.include_router(health.router)

vibetuner/frontend/context.py

@@ -0,0 +1,10 @@
+from vibetuner.context import Context
+
+
+class AppContext(Context):
+    # Add typed state here
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+ctx = AppContext()

vibetuner/frontend/deps.py

@@ -0,0 +1,41 @@
+from typing import Annotated, Optional
+
+from fastapi import Depends, HTTPException, Request
+
+
+async def require_htmx(request: Request) -> None:
+    if not request.state.htmx:
+        raise HTTPException(status_code=400, detail="HTMX header not found")
+
+
+async def enforce_lang(request: Request, lang: Optional[str] = None):
+    if lang is None or lang != request.state.language:
+        redirect_url = request.url_for(
+            request.scope["endpoint"].__name__,
+            **{**request.path_params, "lang": request.state.language},
+        ).path
+        raise HTTPException(
+            status_code=307,
+            detail=f"Redirecting to canonical language: {request.state.language}",
+            headers={"Location": redirect_url},
+        )
+
+    return request.state.language
+
+
+LangDep = Annotated[str, Depends(enforce_lang)]
+
+
+MAGIC_COOKIE_NAME = "magic_access"
+
+
+def require_magic_cookie(request: Request) -> None:
+    """Dependency to check if the magic access cookie is present."""
+    if MAGIC_COOKIE_NAME not in request.cookies:
+        raise HTTPException(status_code=403, detail="Access forbidden")
+
+    if request.cookies[MAGIC_COOKIE_NAME] != "granted":
+        raise HTTPException(status_code=403, detail="Access forbidden")
+
+
+MagicCookieDep = Depends(require_magic_cookie)

vibetuner/frontend/email.py

@@ -0,0 +1,45 @@
+from pydantic import EmailStr
+from starlette_babel import gettext_lazy as _
+
+from vibetuner.config import settings
+from vibetuner.services.email import SESEmailService
+
+from .templates import render_static_template
+
+
+async def send_magic_link_email(
+    ses_service: SESEmailService,
+    lang: str,
+    to_address: EmailStr,
+    login_url: str,
+) -> None:
+    project_name = settings.project.project_name
+
+    html_body = render_static_template(
+        "magic_link.html",
+        namespace="email",
+        lang=lang,
+        context={
+            "login_url": str(login_url),
+            "project_name": project_name,
+        },
+    )
+
+    text_body = render_static_template(
+        "magic_link.txt",
+        namespace="email",
+        lang=lang,
+        context={
+            "login_url": str(login_url),
+            "project_name": project_name,
+        },
+    )
+
+    await ses_service.send_email(
+        subject=_("Sign in to {project_name}").format(
+            project_name=settings.project.project_name
+        ),
+        html_body=html_body,
+        text_body=text_body,
+        to_address=to_address,
+    )

vibetuner/frontend/hotreload.py

@@ -0,0 +1,13 @@
+import arel
+
+from vibetuner.paths import css as css_path, js as js_path, templates as templates_path
+
+
+hotreload = arel.HotReload(
+    paths=[
+        arel.Path(str(js_path)),
+        arel.Path(str(css_path)),
+        arel.Path(str(templates_path)),
+    ],
+    reconnect_interval=2,
+)

vibetuner/frontend/lifespan.py

@@ -0,0 +1,26 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from vibetuner.mongo import init_models
+
+from .context import ctx
+from .hotreload import hotreload
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    if ctx.DEBUG:
+        await hotreload.startup()
+
+    await init_models()
+    # Add below anything that should happen before startup
+
+    # Until here
+    yield
+
+    # Add below anything that should happen before shutdown
+
+    # Until here
+    if ctx.DEBUG:
+        await hotreload.shutdown()

vibetuner/frontend/middleware.py

@@ -0,0 +1,151 @@
+from fastapi import Request, Response
+from fastapi.middleware import Middleware
+from fastapi.requests import HTTPConnection
+from starlette.authentication import AuthCredentials, AuthenticationBackend
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.middleware.trustedhost import TrustedHostMiddleware
+from starlette.types import ASGIApp, Receive, Scope, Send
+from starlette_babel import (
+    LocaleFromCookie,
+    LocaleFromQuery,
+    LocaleMiddleware,
+    get_translator,
+)
+from starlette_htmx.middleware import HtmxMiddleware  # type: ignore[import-untyped]
+
+from vibetuner.config import settings
+from vibetuner.paths import locales as locales_path
+
+from .context import ctx
+from .oauth import WebUser
+
+
+def locale_selector(conn: HTTPConnection) -> str | None:
+    """
+    Selects the locale based on the first part of the path if it matches a 2-letter language code.
+    """
+
+    parts = conn.scope.get("path", "").strip("/").split("/")
+
+    # Check if first part is a 2-letter lowercase language code
+    if parts and len(parts[0]) == 2 and parts[0].islower() and parts[0].isalpha():
+        return parts[0]
+
+    return None
+
+
+def user_preference_selector(conn: HTTPConnection) -> str | None:
+    """
+    Selects the locale based on authenticated user's language preference from session.
+    This takes priority over all other locale selectors to avoid database queries.
+    """
+    # Check if session is available in scope
+    if "session" not in conn.scope:
+        return None
+
+    session = conn.scope["session"]
+    if not session:
+        return None
+
+    user_data = session.get("user")
+    if not user_data:
+        return None
+
+    # Get language preference from user settings stored in session
+    user_settings = user_data.get("settings")
+    if not user_settings:
+        return None
+
+    language = user_settings.get("language")
+    if language and isinstance(language, str) and len(language) == 2:
+        return language.lower()
+
+    return None
+
+
+shared_translator = get_translator()
+if locales_path.exists() and locales_path.is_dir():
+    # Load translations from the locales directory
+    shared_translator.load_from_directories([locales_path])
+
+
+class AdjustLangCookieMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        response: Response = await call_next(request)
+
+        lang_cookie = request.cookies.get("language")
+        if not lang_cookie or lang_cookie != request.state.language:
+            response.set_cookie(
+                key="language", value=request.state.language, max_age=3600
+            )
+
+        return response
+
+
+class ForwardedProtocolMiddleware:
+    def __init__(self, app: ASGIApp):
+        self.app = app
+
+    # Based on https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "lifespan":
+            return await self.app(scope, receive, send)
+
+        headers = dict(scope["headers"])
+
+        if b"x-forwarded-proto" in headers:
+            x_forwarded_proto = headers[b"x-forwarded-proto"].decode("latin1").strip()
+
+            if x_forwarded_proto in {"http", "https", "ws", "wss"}:
+                if scope["type"] == "websocket":
+                    scope["scheme"] = x_forwarded_proto.replace("http", "ws")
+                else:
+                    scope["scheme"] = x_forwarded_proto
+
+        return await self.app(scope, receive, send)
+
+
+class AuthBackend(AuthenticationBackend):
+    async def authenticate(
+        self,
+        conn: HTTPConnection,
+    ) -> tuple[AuthCredentials, WebUser] | None:
+        if user := conn.session.get("user"):
+            try:
+                return (
+                    AuthCredentials(["authenticated"]),
+                    WebUser.model_validate(user),
+                )
+            except Exception:
+                # Clear corrupted session data and continue unauthenticated
+                conn.session.pop("user", None)
+                return None
+
+        return None
+
+
+# Until this line
+middlewares: list[Middleware] = [
+    Middleware(TrustedHostMiddleware),
+    Middleware(ForwardedProtocolMiddleware),
+    Middleware(HtmxMiddleware),
+    Middleware(SessionMiddleware, secret_key=settings.session_key.get_secret_value()),
+    Middleware(
+        LocaleMiddleware,
+        locales=list(ctx.supported_languages),
+        default_locale=ctx.default_language,
+        selectors=[
+            LocaleFromQuery(query_param="l"),
+            locale_selector,
+            user_preference_selector,
+            LocaleFromCookie(),
+        ],
+    ),
+    Middleware(AdjustLangCookieMiddleware),
+    Middleware(AuthenticationMiddleware, backend=AuthBackend()),
+    # Add your middleware below this line
+]
+
+# EOF

vibetuner/frontend/oauth.py

@@ -0,0 +1,196 @@
+from typing import Optional
+
+from authlib.integrations.base_client.errors import OAuthError
+from authlib.integrations.starlette_client import OAuth  # ty: ignore[unresolved-import]
+from fastapi import Request
+from fastapi.responses import RedirectResponse
+from pydantic import BaseModel, Field
+from pydantic_extra_types.language_code import LanguageAlpha2
+from starlette.authentication import BaseUser
+
+from vibetuner.frontend.routes import get_homepage_url
+from vibetuner.models.oauth import OAuthAccountModel, OauthProviderModel
+from vibetuner.models.user import UserModel
+
+
+DEFAULT_AVATAR_IMAGE = "/statics/img/user-avatar.png"
+
+_PROVIDERS: dict[str, OauthProviderModel] = {}
+
+
+def register_oauth_provider(name: str, provider: OauthProviderModel) -> None:
+    _PROVIDERS[name] = provider
+    PROVIDER_IDENTIFIERS[name] = provider.identifier
+    _oauth_config.update(**provider.config)
+    register_kwargs = {"client_kwargs": provider.client_kwargs, **provider.params}
+    oauth.register(name, overwrite=True, **register_kwargs)
+
+
+class WebUser(BaseUser, BaseModel):
+    id: str
+    name: str
+    email: str
+    picture: Optional[str] = Field(
+        default=DEFAULT_AVATAR_IMAGE,
+        description="URL to the user's avatar image",
+    )
+    language: Optional[LanguageAlpha2] = Field(
+        default=None,
+        description="Preferred language for the user",
+    )
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def display_name(self) -> str:
+        return self.name
+
+
+class Config:
+    def __init__(self, **kwargs):
+        self._data = kwargs
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def update(self, **kwargs):
+        self._data.update(kwargs)
+
+
+_oauth_config = Config()
+oauth = OAuth(_oauth_config)
+
+PROVIDER_IDENTIFIERS: dict[str, str] = {}
+
+
+def get_oauth_providers() -> list[str]:
+    return list(_PROVIDERS.keys())
+
+
+async def _handle_user_account(
+    provider: str, identifier: str, email: str, name: str, picture: str
+) -> UserModel:
+    """Handle user account creation or OAuth linking."""
+    # Check if OAuth account already exists
+    oauth_account = await OAuthAccountModel.get_by_provider_and_id(
+        provider=provider,
+        provider_user_id=identifier,
+    )
+
+    if oauth_account:
+        # OAuth account exists, get linked user account
+        account = await UserModel.get_by_email(email)
+        if not account:
+            raise OAuthError("No account linked to this OAuth account")
+        return account
+
+    # OAuth account doesn't exist, check if user exists
+
+    if account := (await UserModel.get_by_email(email)):
+        # User exists, link OAuth account
+        await _link_oauth_account(account, provider, identifier, email, name, picture)
+    else:
+        # New user, create account and OAuth link
+        account = await _create_new_user_with_oauth(
+            provider, identifier, email, name, picture
+        )
+
+    return account
+
+
+async def _link_oauth_account(
+    account: UserModel,
+    provider: str,
+    identifier: str,
+    email: str,
+    name: str,
+    picture: str,
+) -> None:
+    """Link OAuth account to existing user."""
+    oauth_account = OAuthAccountModel(
+        provider=provider,
+        provider_user_id=identifier,
+        email=email,
+        name=name,
+        picture=picture,
+    )
+    await oauth_account.insert()
+    account.oauth_accounts.append(oauth_account)
+    await account.save()
+
+
+async def _create_new_user_with_oauth(
+    provider: str, identifier: str, email: str, name: str, picture: str
+) -> UserModel:
+    """Create new user account with OAuth linking."""
+    # Create user account
+    oauth_account = OAuthAccountModel(
+        provider=provider,
+        provider_user_id=identifier,
+        email=email,
+        name=name,
+        picture=picture,
+    )
+    await oauth_account.insert()
+
+    account = UserModel(
+        email=email,
+        name=name,
+        picture=picture,
+        oauth_accounts=[oauth_account],
+    )
+    await account.insert()
+
+    return account
+
+
+def _create_auth_login_handler(provider_name: str):
+    async def auth_login(request: Request, next: str | None = None):
+        redirect_uri = request.url_for(f"auth_with_{provider_name}")
+        request.session["next_url"] = next or get_homepage_url(request)
+        client = oauth.create_client(provider_name)
+        if not client:
+            return RedirectResponse(url=get_homepage_url(request))
+
+        return await client.authorize_redirect(
+            request, redirect_uri, hl=request.state.language
+        )
+
+    return auth_login
+
+
+def _create_auth_handler(provider_name: str):
+    async def auth_handler(request: Request):
+        """Handle OAuth authentication flow."""
+        try:
+            # Initialize OAuth client
+            client = oauth.create_client(provider_name)
+            if not client:
+                return get_homepage_url(request)
+
+            # Get user info from OAuth provider
+            token = await client.authorize_access_token(request)
+            userinfo = token.get("userinfo")
+            if not userinfo:
+                raise OAuthError("No userinfo found in token")
+
+            # Extract user data
+            identifier = userinfo.get(PROVIDER_IDENTIFIERS[provider_name])
+            email = userinfo.get("email")
+            name = userinfo.get("name")
+            picture = userinfo.get("picture")
+
+            # Handle user account creation/linking
+            account = await _handle_user_account(
+                provider_name, identifier, email, name, picture
+            )
+
+            # Set session and redirect
+            request.session["user"] = account.session_dict
+            return request.session.pop("next_url", get_homepage_url(request))
+        except OAuthError:
+            return get_homepage_url(request)
+
+    return auth_handler

vibetuner/frontend/routes/__init__.py

@@ -0,0 +1,12 @@
+from fastapi import Request
+
+
+def get_homepage_url(request: Request, path_only: bool = True) -> str:
+    """Get homepage URL for the current language."""
+    try:
+        url = request.url_for("homepage", lang=request.state.language)
+    except Exception:
+        # Fallback to default language if the requested language is not available
+        url = request.url_for("homepage")
+
+    return url.path if path_only else str(url)