fastapi-auth-toolkit

FastAPI Auth Toolkit [Beanie]

The FastAPI Auth Toolkit [Beanie] provides a comprehensive authentication solution for FastAPI applications. It offers robust features for user authentication, registration, and account management, and supports integration with popular third-party social authentication platforms.

Features

• User Authentication and Registration: Securely manage user accounts with built-in authentication and registration capabilities.
• Account Management: Easily handle user profiles and account details.
• Third-Party Social Authentication: Integrate with major social platforms for seamless social login functionality.
• Simple Configuration: Effortlessly configure and set up with straightforward integration steps.

Installation

You can install the fastapi-auth-toolkit[beanie] package using either pip or pipenv.

Using pip

To install the package with pip, execute:

pip install fastapi-auth-toolkit[beanie]

Project Configuration

• In your FastAPI application, typically located in main.py or another startup file, integrate the authentication routes and load the configuration as follows:

1. Setup database connection and collection - db.py

• The first thing to do is to create a MongoDB connection using mongodb/motor (automatically installed with Beanie).

from motor.motor_asyncio import AsyncIOMotorClient

# Database configuration
DATABASE_URL = "mongodb://localhost:27017"
database_name = "database_name"

# Create a MongoDB client and get the database instance
database_client = AsyncIOMotorClient(
    DATABASE_URL, uuidRepresentation="standard"
)
database = database_client.get_database(database_name)

2. Initialize Beanie - db.py

• When initializing your FastAPI app, it's important that you initialize Beanie so it can discover your models. We can achieve this using Lifespan Events on the FastAPI app

from typing import List, Type
from beanie import init_beanie, Document

# Document model registry
document_models_registry: List[Type[Document]] = []

async def init_database():
    try:
        # Initialize Beanie with the provided document models and database
        await init_beanie(
            database=database,
            document_models=document_models_registry
        )
        print("Beanie initialized successfully.")
    except Exception as e:
        print(f"Error initializing Beanie: {e}")
        raise

3. Configuration - main.py

from fastapi import FastAPI
from contextlib import asynccontextmanager

from fastapi_auth_toolkit import FastapiAuthToolkitConfig
from db import document_models_registry, init_database


@asynccontextmanager
async def lifespan(app: FastAPI):
    """
    Asynchronous context manager to handle application lifespan events.

    :param app: The FastAPI application instance.
    """

    # Initialize FastAPI Auth Toolkit
    FastapiAuthToolkitConfig(
        app=app,
        document_models=document_models_registry,
    )

    # Initialize beanie document
    await init_database()

    # Yield control back to the FastAPI app
    yield

# Create your FastAPI app
app = FastAPI(lifespan=lifespan)

Authentication Method - jwt, session, or cookies

1. session based auth.

from fastapi_auth_toolkit import FastapiAuthToolkitConfig

FastapiAuthToolkitConfig(
    auth_method="session",
)

2. cookies based auth.

from fastapi_auth_toolkit import FastapiAuthToolkitConfig

FastapiAuthToolkitConfig(
    auth_method="cookies",
)

3. jwt based auth - fully customized.

• Initialize FastAPI Auth Toolkit with optional custom JWT settings

from datetime import timedelta
from fastapi_auth_toolkit import FastapiAuthToolkitConfig

FastapiAuthToolkitConfig(
    auth_method="jwt",
    jwt_settings={
        "access_token_lifetime": timedelta(minutes=5),  # Example JWT settings
        "refresh_token_lifetime": timedelta(days=1),
        "update_last_login": False,
        "algorithm": "HS256",
        "auth_header_types": "Bearer",
        "auth_header_name": "HTTP_AUTHORIZATION",
        "user_id_field": "user_id"
    },
)