Add Auth Endpoints

# src/routes/auth_routes.py

# Imports you'll need for all auth endpoints
from fastapi import APIRouter, Depends, Request, Response
from wristband.fastapi_auth import (
  CallbackResult,
  get_session,
  LogoutConfig,
  RedirectRequiredCallbackResult,
  SessionResponse,
  TokenResponse
)
from auth.wristband import require_session_auth, wristband_auth

router = APIRouter()

# Login Endpoint
@router.get('/login')
async def login(request: Request) -> Response:
    # Call the Wristband login() method which will generate the Response that 
    # should be used to redirect to Wristband's Authorize Endpoint.
    return await wristband_auth.login(request)

...

# src/routes/auth_routes.py (continued)

# ...

# Callback Endpoint - The get_session dependency provides access to the 
# session object without performing validations on the session.
@router.get('/callback')
async def callback(request: Request, session: Session = Depends(get_session)) -> Response:
    # Call the Wristband callback() method to check if the user
    # successfully authenticated.  If the user did authenticate successfully, 
    # the user's tokens and claims can be retrieved from the CallbackResult.
    callback_result: CallbackResult = await wristband_auth.callback(request)

    # For some edge cases, such as if an invalid grant was passed to the token
    # API, the SDK will return a redirect URL. Your code should redirect to it
    # in order to restart the login flow.
    if isinstance(callback_result, RedirectRequiredCallbackResult):
        return await wristband_auth.create_callback_response(
            request,
            callback_result.redirect_url,
        )
    
    # Create a session for the authenticated user. If needed, custom fields can 
    # be stored in the session using the custom_fields parameter of the 
    # from_callback() method.
    session.from_callback(callback_result.callback_data)

    # Once the Callback Endpoint has completed, redirect to your app's
    # default return URL (typically your app's home page) or to an explicit
    # return URL, if one was specified in the original login request.
    app_url = callback_result.callback_data.return_url or "<replace-with-default-app-url>"
    return await wristband_auth.create_callback_response(request, app_url)

...

# src/routes/auth_routes.py (continued)

...

# Logout Endpoint
@router.get('/logout')
async def logout(request: Request, session: Session = Depends(get_session)) -> Response:
    # Get all the necessary session data needed to perform the logout operation.
    logout_config = LogoutConfig(
        refresh_token=session.refresh_token,
        tenant_custom_domain=session.tenant_custom_domain,
        tenant_name=session.tenant_name,
    )

    # Clear your application's local session.
    session.clear()

    # Call the Wristband logout() method. This will revoke any refresh tokens
    # associated with the user and return a Response to redirect to Wristband's 
    # Logout Endpoint.  Redirecting to Wristband's Logout Endpoint will terminate 
    # Wristband's auth session associated to the user.  When Wristband is done
    # logging out the user it will redirect back to your application's login 
    # URL or to an explicitly provided redirect URL.
    return await wristband_auth.logout(request, logout_config)

...

# src/routes/auth_routes.py (continued)

...

# Session Endpoint - The `require_session_auth` dependency verifies that the 
# request has a valid session and also provides access to the session object.
@router.get("/session")
async def get_session_response(session: Session = Depends(require_session_auth)) -> SessionResponse:
    # Call the Wristband get_session_response() method to extract the user's 
    # session data and populate a SessionResponse. If needed, you can add 
    # additional data to the SessionResponse by using the metadata parameter 
    # of the get_session_response() method.
    return session.get_session_response()

# src/main.py
from fastapi import FastAPI
from wristband.fastapi_auth import SessionMiddleware
from routes.auth_routes import router as auth_router # <-- NEW

def create_app() -> FastAPI:
    app = FastAPI()

    app.add_middleware(SessionMiddleware, secret_key="<your-generated-secret>")

    # NEW: Include auth routes - path prefix can be whatever you prefer.
    app.include_router(auth_router, prefix="/auth")

    # Your other application setup...