fast-jelly! the Gel auth extension bindings for FastAPI

python-fastapi/examples/basic-async/README.md

@@ -1,7 +1,7 @@
 # Basic Async Example
 
 ```console
-$ uv run main.py
+$ uv run uvicorn app.main:fast_api
 ```
 
 ## Development

python-fastapi/examples/basic-async/app/auth.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+from typing import Annotated
+
+import json
+import logging
+from http import HTTPStatus
+
+from fastapi import APIRouter, Depends, Form
+from fastapi.responses import RedirectResponse
+from gel_auth_fastapi import (
+    make_email_password,
+    email_password as core_email_password,
+)
+
+from .config import BASE_URL
+from .gel_client import client
+from .queries import create_user_async_edgeql as create_user_qry
+
+logger = logging.getLogger("fast_jelly")
+router = APIRouter()
+email_password = make_email_password(
+    client,
+    verify_url=f"{BASE_URL}/auth/verify",
+    reset_url=f"{BASE_URL}/ui/reset-password",
+)
+
+
+@router.post(
+    "/auth/register",
+    response_class=RedirectResponse,
+    status_code=HTTPStatus.SEE_OTHER,
+)
+async def register(
+    email: Annotated[str, Form()],
+    sign_up_response: Annotated[
+        core_email_password.SignUpResponse, Depends(email_password.handle_sign_up)
+    ],
+):
+    if not isinstance(sign_up_response, core_email_password.SignUpFailedResponse):
+        user = await create_user_qry.create_user(
+            client,
+            name=email,
+            identity_id=sign_up_response.identity_id,
+        )
+        print(f"Created user: {json.dumps(user, default=str)}")
+
+    match sign_up_response:
+        case core_email_password.SignUpCompleteResponse():
+            return "/"
+        case core_email_password.SignUpVerificationRequiredResponse():
+            return "/signin?incomplete=verification_required"
+        case core_email_password.SignUpFailedResponse():
+            logger.error("sign up failed: %s", sign_up_response)
+            return "/signin?error=failure"
+        case _:
+            raise Exception("Invalid sign up response")
+
+
+@router.post(
+    "/auth/authenticate",
+    response_class=RedirectResponse,
+    status_code=HTTPStatus.SEE_OTHER,
+)
+async def authenticate(
+    sign_in_response: Annotated[
+        core_email_password.SignInResponse, Depends(email_password.handle_sign_in)
+    ],
+):
+    match sign_in_response:
+        case core_email_password.SignInCompleteResponse():
+            return "/"
+        case core_email_password.SignInVerificationRequiredResponse():
+            return "/signin?incomplete=verification_required"
+        case core_email_password.SignInFailedResponse():
+            logger.error("sign in failed: %s", sign_in_response)
+            return "/signin?error=failure"
+        case _:
+            raise Exception("Invalid sign in response")
+
+
+@router.get(
+    "/auth/verify",
+    response_class=RedirectResponse,
+    status_code=HTTPStatus.SEE_OTHER,
+)
+async def verify(
+    verify_response: Annotated[
+        core_email_password.EmailVerificationResponse,
+        Depends(email_password.handle_verify_email),
+    ],
+):
+    match verify_response:
+        case core_email_password.EmailVerificationCompleteResponse():
+            return "/"
+        case core_email_password.EmailVerificationMissingProofResponse():
+            return "/signin?incomplete=verify"
+        case core_email_password.EmailVerificationFailedResponse():
+            logger.error("verify email failed: %s", verify_response)
+            return "/signin?error=failure"
+        case _:
+            raise Exception("Invalid verify email response")
+
+
+@router.post(
+    "/auth/send-password-reset",
+    response_class=RedirectResponse,
+    status_code=HTTPStatus.SEE_OTHER,
+)
+async def send_password_reset(
+    send_password_reset_response: Annotated[
+        core_email_password.SendPasswordResetEmailResponse,
+        Depends(email_password.handle_send_password_reset),
+    ],
+):
+    match send_password_reset_response:
+        case core_email_password.SendPasswordResetEmailCompleteResponse():
+            return "/signin?incomplete=password_reset_sent"
+        case core_email_password.SendPasswordResetEmailFailedResponse():
+            logger.error(
+                "send password reset failed: %s", send_password_reset_response
+            )
+            return "/signin?error=failure"
+        case _:
+            raise Exception("Invalid send password reset response")
+
+
+@router.post(
+    "/auth/reset-password",
+    response_class=RedirectResponse,
+    status_code=HTTPStatus.SEE_OTHER,
+)
+async def reset_password(
+    reset_password_response: Annotated[
+        core_email_password.PasswordResetResponse,
+        Depends(email_password.handle_reset_password),
+    ],
+):
+    match reset_password_response:
+        case core_email_password.PasswordResetCompleteResponse():
+            return "/"
+        case core_email_password.PasswordResetMissingProofResponse():
+            return "/signin?incomplete=reset_password"
+        case core_email_password.PasswordResetFailedResponse():
+            logger.error("reset password failed: %s", reset_password_response)
+            return "/signin?error=failure"
+        case _:
+            raise Exception("Invalid reset password response")

python-fastapi/examples/basic-async/app/config.py

@@ -0,0 +1,6 @@
+import os
+
+
+APP_HOST = os.getenv("APP_HOST", default="localhost")
+APP_PORT = os.getenv("APP_PORT", default="8000")
+BASE_URL = f"http://{APP_HOST}:{APP_PORT}"

python-fastapi/examples/basic-async/app/configure_auth.py

@@ -0,0 +1,52 @@
+import asyncio
+import os
+import secrets
+
+from gel import create_async_client
+
+
+async def main():
+    client = create_async_client()
+
+    auth_signing_key = os.getenv("GEL_AUTH_SIGNING_KEY", secrets.token_urlsafe(32))
+
+    await client.execute(
+        f"""
+configure current branch reset ext::auth::AuthConfig;
+configure current branch reset ext::auth::ProviderConfig;
+configure current branch reset ext::auth::EmailPasswordProviderConfig;
+configure current branch reset cfg::EmailProviderConfig;
+
+configure current branch set
+ext::auth::AuthConfig::auth_signing_key := "{auth_signing_key}";
+
+configure current branch set
+ext::auth::AuthConfig::app_name := "Fast Jelly";
+
+configure current branch set
+ext::auth::AuthConfig::allowed_redirect_urls := {{"http://localhost:8000"}};
+
+configure current branch insert
+ext::auth::EmailPasswordProviderConfig {{
+    require_verification := true,
+}};
+
+configure current branch insert
+cfg::SMTPProviderConfig {{
+    name := "mailpit",
+    host := "localhost",
+    port := 1025,
+    username := "smtpuser",
+    password := "smtppassword",
+    sender := "[email protected]",
+    validate_certs := false,
+}};
+
+configure current branch set
+cfg::current_email_provider_name := "mailpit";
+        """
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python-fastapi/examples/basic-async/app/events.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+import gel
+from fastapi import APIRouter, HTTPException
+from gel_auth_fastapi import SessionDep
+from pydantic import BaseModel
+
+from .queries import (
+    create_event_async_edgeql as create_event_qry,
+)
+
+router = APIRouter()
+
+
+class RequestData(BaseModel):
+    name: str
+    address: str
+    schedule: datetime.datetime
+    host_name: str
+
+
+@router.post("/events", status_code=HTTPStatus.CREATED)
+async def post_event(
+    event: RequestData, session: SessionDep
+) -> create_event_qry.CreateEventResult:
+    client = session.client
+    try:
+        created_event = await create_event_qry.create_event(
+            client,
+            name=event.name,
+            address=event.address,
+            schedule=event.schedule,
+            host_name=event.host_name,
+        )
+    except gel.errors.InvalidValueError as ex:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail={"error": str(ex)},
+        )
+
+    except gel.errors.ConstraintViolationError:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail={"error": "Event '{event.name}' already exists"},
+        )
+
+    return created_event

python-fastapi/examples/basic-async/app/gel_client.py

@@ -0,0 +1,4 @@
+import gel
+
+
+client = gel.create_async_client()

python-fastapi/examples/basic-async/app/main.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+import sys
+
+from fastapi import FastAPI, APIRouter
+
+from app import auth, users, events, ui
+
+
+formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+stream_handler = logging.StreamHandler(sys.stdout)
+stream_handler.setFormatter(formatter)
+
+logger = logging.getLogger("fast_jelly")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(stream_handler)
+
+auth_core_logger = logging.getLogger("gel.auth")
+auth_core_logger.setLevel(logging.DEBUG)
+auth_core_logger.addHandler(stream_handler)
+
+fast_api = FastAPI()
+fast_api.include_router(ui.router)
+fast_api.include_router(auth.router)
+
+api_router = APIRouter()
+api_router.include_router(users.router)
+api_router.include_router(events.router)
+
+fast_api.include_router(api_router, prefix="/api")

python-fastapi/examples/basic-async/app/queries/create_event.edgeql

@@ -0,0 +1,16 @@
+with
+    name := <str>$name,
+    address := <str>$address,
+    schedule := <datetime>$schedule,
+    host_name := <str>$host_name,
+
+    HOST := (select default::User filter .name = host_name),
+    CREATED := (
+        insert default::Event {
+            name := name,
+            address := address,
+            schedule := schedule,
+            host := HOST,
+        }
+    ),
+select CREATED { *, host: { * } };