Shared dependencies across routers in FastAPI - Mini Project: Build & Apply

Shared dependencies across routers in FastAPI

📖 Scenario: You are building a web API for a simple book store. You want to organize your API into separate routers for books and authors. Both routers need to check a shared dependency that simulates user authentication.

🎯 Goal: Create two routers, books_router and authors_router, each with one route. Add a shared dependency get_current_user to both routers so that the user is authenticated before accessing any route.

📋 What You'll Learn

Create a dependency function called get_current_user that returns a string 'user123'.

Create a FastAPI app instance called app.

Create two routers: books_router and authors_router.

Add the get_current_user dependency to both routers using the dependencies parameter.

Add one route /books/ to books_router that returns a JSON with key 'message' and value 'Books list'.

Add one route /authors/ to authors_router that returns a JSON with key 'message' and value 'Authors list'.

Include both routers in the main app with prefixes /books and /authors respectively.

💡 Why This Matters

🌍 Real World

In real web APIs, shared dependencies like authentication or database sessions are used across multiple routers to keep code clean and secure.

💼 Career

Understanding how to share dependencies across routers is essential for building scalable and maintainable FastAPI applications in professional backend development.

1

Create the shared dependency function

Create a function called get_current_user that returns the string 'user123'.

FastAPI

# Your code here

Hint

This function simulates user authentication by returning a fixed user ID.

2

Create FastAPI app and routers with shared dependency

Import FastAPI and APIRouter from fastapi. Create a FastAPI app called app. Create two routers called books_router and authors_router with the shared dependency get_current_user added using the dependencies parameter.

FastAPI

def get_current_user():
    return 'user123'

# Your code here

Hint

Use Depends(get_current_user) inside the dependencies list when creating each router.

3

Add routes to routers

Add a GET route / to books_router that returns {'message': 'Books list'}. Add a GET route / to authors_router that returns {'message': 'Authors list'}.

FastAPI

from fastapi import FastAPI, APIRouter, Depends

def get_current_user():
    return 'user123'

app = FastAPI()

books_router = APIRouter(dependencies=[Depends(get_current_user)])
authors_router = APIRouter(dependencies=[Depends(get_current_user)])

# Your code here

Hint

Use the @router.get('/') decorator and define functions that return the required dictionaries.

4

Include routers in the main app

Include books_router in app with prefix /books. Include authors_router in app with prefix /authors.

FastAPI

from fastapi import FastAPI, APIRouter, Depends

def get_current_user():
    return 'user123'

app = FastAPI()

books_router = APIRouter(dependencies=[Depends(get_current_user)])
authors_router = APIRouter(dependencies=[Depends(get_current_user)])

@books_router.get('/')
def read_books():
    return {'message': 'Books list'}

@authors_router.get('/')
def read_authors():
    return {'message': 'Authors list'}

# Your code here

Hint

Use app.include_router() with the correct router and prefix.

Practice

1. What is the main benefit of using shared dependencies across routers in FastAPI?

easy

A. To disable dependency injection in routers

B. To make the API slower by adding extra layers

C. To force all routers to use the same path prefix

D. To avoid repeating the same dependency code in multiple routers

Solution

1. Step 1: Understand what shared dependencies do

   Shared dependencies allow you to write a dependency once and apply it to many routers, avoiding repetition.

2. Step 2: Identify the benefit in code maintenance

   This reduces duplicate code and makes the project easier to maintain and update.

3. Final Answer:

   To avoid repeating the same dependency code in multiple routers -> Option D

4. Quick Check:

   Shared dependencies = avoid repetition [OK]

Hint: Shared dependencies reduce repeated code across routers [OK]

Common Mistakes:

• Thinking shared dependencies slow down the API
• Confusing shared dependencies with path prefixes
• Believing shared dependencies disable injection

2. Which is the correct way to apply a shared dependency to an APIRouter in FastAPI?

easy

A. router = APIRouter(shared_dependencies=[Depends(common_dep)])

B. router = APIRouter(dependencies=[Depends(common_dep)])

C. router = APIRouter(dependency=Depends(common_dep))

D. router = APIRouter(shared=Depends(common_dep))

Solution

1. Step 1: Recall the APIRouter parameter for dependencies

   The correct parameter name is dependencies, which takes a list of Depends objects.

2. Step 2: Match the syntax to the correct option

   router = APIRouter(dependencies=[Depends(common_dep)]) uses dependencies=[Depends(common_dep)], which is the correct syntax.

3. Final Answer:

   router = APIRouter(dependencies=[Depends(common_dep)]) -> Option B

4. Quick Check:

   dependencies param = correct syntax [OK]

Hint: Use 'dependencies' param with a list of Depends [OK]

Common Mistakes:

• Using 'shared_dependencies' instead of 'dependencies'
• Passing Depends directly without a list
• Using wrong parameter names like 'dependency' or 'shared'

3. Given this code snippet, what will be printed when accessing /items/42?

from fastapi import FastAPI, APIRouter, Depends

app = FastAPI()

def common_dep():
    print("Common dependency called")

router = APIRouter(dependencies=[Depends(common_dep)])

@router.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

app.include_router(router)

medium

A. "Common dependency called" is printed once per request

B. An error occurs because common_dep is not awaited

C. Nothing is printed

D. "Common dependency called" is printed twice per request

Solution

1. Step 1: Understand how dependencies run in FastAPI

   Dependencies listed in the router's dependencies run for every matching request automatically.

2. Step 2: Analyze the print statement in common_dep

   Each time the endpoint is called, common_dep runs and prints "Common dependency called" once.

3. Final Answer:

   "Common dependency called" is printed once per request -> Option A

4. Quick Check:

   Router dependencies run once per request [OK]

Hint: Router dependencies run once per matching request [OK]

Common Mistakes:

• Thinking dependencies run multiple times per request
• Expecting no output from print statements
• Confusing async with sync dependencies causing errors

4. Identify the error in this FastAPI router setup with shared dependencies:

from fastapi import APIRouter, Depends

def verify_token():
    pass

router = APIRouter(dependencies=Depends(verify_token))

@router.get("/secure")
async def secure_endpoint():
    return {"message": "Secure"}

medium

A. Depends should be inside a list in dependencies parameter

B. verify_token must return a value

C. APIRouter cannot have dependencies

D. The route path must start with a slash

Solution

1. Step 1: Check the dependencies parameter type

   The dependencies parameter expects a list of Depends objects, not a single Depends instance.

2. Step 2: Identify the correct syntax

   It should be dependencies=[Depends(verify_token)] to be valid.

3. Final Answer:

   Depends should be inside a list in dependencies parameter -> Option A

4. Quick Check:

   dependencies param requires a list [OK]

Hint: Always wrap Depends in a list for dependencies param [OK]

Common Mistakes:

• Passing Depends directly without list
• Assuming dependencies param accepts single Depends
• Ignoring syntax errors from wrong dependencies format

5. You want to apply a shared dependency that extracts a user from a token to two routers, router_a and router_b. Which approach correctly shares the dependency without repeating code?

hard

A. Define the dependency in each route function separately in both routers

B. Include get_current_user as a parameter in FastAPI() app initialization

C. Add the dependency to each router using the dependencies parameter with Depends(get_current_user)

D. Use global variables to store the user and access it in routes

Solution

1. Step 1: Understand how to share dependencies across routers

   Using the dependencies parameter in APIRouter allows applying a dependency to all routes in that router.

2. Step 2: Apply the dependency to both routers

   Adding dependencies=[Depends(get_current_user)] to both router_a and router_b shares the logic without repeating it in each route.

3. Final Answer:

   Add the dependency to each router using the dependencies parameter with Depends(get_current_user) -> Option C

4. Quick Check:

   Shared dependencies via router dependencies param [OK]

Hint: Use dependencies param on routers to share common logic [OK]

Common Mistakes:

• Repeating dependency code in every route
• Trying to add dependencies in FastAPI app instead of routers
• Using global variables instead of dependency injection