Shared dependencies in FastAPI - Mini Project: Build & Apply

Using Shared Dependencies in FastAPI

📖 Scenario: You are building a simple web API with FastAPI. You want to reuse a common dependency that provides a database connection object for multiple API endpoints.

🎯 Goal: Create a FastAPI app that uses a shared dependency function to provide a database connection string to two different endpoints.

📋 What You'll Learn

Create a dependency function called get_db that returns the string 'db_connection'.

Create a FastAPI app instance called app.

Create two GET endpoints: /items/ and /users/.

Both endpoints must use the get_db dependency to receive the database connection string.

Each endpoint should return a JSON response with a key db and the value from the dependency.

💡 Why This Matters

🌍 Real World

Shared dependencies in FastAPI help avoid repeating code for common resources like database connections, authentication, or configuration.

💼 Career

Understanding shared dependencies is essential for building scalable and maintainable APIs in professional FastAPI development.

1

Create the shared dependency function

Create a function called get_db that returns the string 'db_connection'.

FastAPI

# Your code here

Hint

Define a simple function named get_db that returns the string 'db_connection'.

2

Create the FastAPI app instance

Import FastAPI from fastapi and create an app instance called app.

FastAPI

def get_db():
    return 'db_connection'

# Your code here

Hint

Use from fastapi import FastAPI and then create app = FastAPI().

3

Create the /items/ endpoint using the shared dependency

Create a GET endpoint /items/ using @app.get("/items/"). Add a parameter db that uses Depends(get_db). Return a dictionary with key db and value db.

FastAPI

from fastapi import FastAPI
from fastapi import Depends

def get_db():
    return 'db_connection'

app = FastAPI()

# Your code here

Hint

Use @app.get("/items/") and a function with parameter db: str = Depends(get_db). Return {"db": db}.

4

Create the /users/ endpoint using the shared dependency

Create a GET endpoint /users/ using @app.get("/users/"). Add a parameter db that uses Depends(get_db). Return a dictionary with key db and value db.

FastAPI

from fastapi import FastAPI
from fastapi import Depends

def get_db():
    return 'db_connection'

app = FastAPI()

@app.get("/items/")
def read_items(db: str = Depends(get_db)):
    return {"db": db}

# Your code here

Hint

Repeat the pattern from the previous step for the /users/ endpoint.

Practice

1. What is the main purpose of using Depends() in FastAPI for shared dependencies?

easy

A. To reuse code across multiple routes by declaring common dependencies

B. To create a new route in the application

C. To handle database connections manually

D. To define the response model for an endpoint

Solution

1. Step 1: Understand the role of Depends()

   Depends() is used in FastAPI to declare dependencies that can be shared across multiple routes.

2. Step 2: Identify the main benefit

   Using shared dependencies helps reuse code and keep the app clean and maintainable.

3. Final Answer:

   To reuse code across multiple routes by declaring common dependencies -> Option A

4. Quick Check:

   Shared dependencies = reuse code [OK]

Hint: Depends() means shared code for many routes [OK]

Common Mistakes:

• Thinking Depends() creates routes
• Confusing Depends() with response models
• Assuming Depends() manages database connections directly

2. Which of the following is the correct way to declare a shared dependency in a FastAPI route?

easy

A. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass

B. def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass

C. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass

D. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass

Solution

1. Step 1: Review correct dependency syntax

   In FastAPI, dependencies are declared using Depends(function_name) inside the function parameters.

2. Step 2: Check each option

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass correctly uses db=Depends(get_db). def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass calls the function directly, which is incorrect. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass lacks Depends, so no injection happens. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass uses Depends without a function, which is invalid.

3. Final Answer:

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass -> Option A

4. Quick Check:

   Depends() needs function inside [OK]

Hint: Depends() must wrap the dependency function [OK]

Common Mistakes:

• Calling dependency function directly in parameter
• Forgetting to use Depends() wrapper
• Using Depends() without specifying the function

3. Given the code below, what will be the output when accessing /items/42?

from fastapi import FastAPI, Depends

app = FastAPI()

def common_dep():
    return "shared value"

@app.get('/items/{item_id}')
def read_item(item_id: int, value: str = Depends(common_dep)):
    return {"item_id": item_id, "value": value}

medium

A. Error: Missing required parameter 'value'

B. {"item_id": 42, "value": 42}

C. {"item_id": 42, "value": null}

D. {"item_id": 42, "value": "shared value"}

Solution

1. Step 1: Understand dependency injection

   The function common_dep returns the string "shared value". FastAPI injects this into the value parameter via Depends(common_dep).

2. Step 2: Check the returned JSON

   The route returns a dictionary with item_id from the path and value from the dependency. So the output will be {"item_id": 42, "value": "shared value"}.

3. Final Answer:

   {"item_id": 42, "value": "shared value"} -> Option D

4. Quick Check:

   Dependency injects "shared value" [OK]

Hint: Depends injects return value as parameter [OK]

Common Mistakes:

• Assuming dependency returns item_id
• Expecting error due to missing parameter
• Thinking value will be null without explicit call

4. Identify the error in the following FastAPI code using shared dependencies:

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "token123"

@app.get('/secure')
def secure_route(token: str = Depends()):
    return {"token": token}

medium

A. The function secure_route should not have parameters

B. The dependency function get_token() should return an int

C. Depends() is missing the dependency function inside

D. The route decorator is missing parentheses

Solution

1. Step 1: Check Depends usage

   The parameter token uses Depends() without specifying the dependency function. This is incorrect syntax.

2. Step 2: Correct usage

   Depends must wrap the function providing the dependency, so it should be Depends(get_token).

3. Final Answer:

   Depends() is missing the dependency function inside -> Option C

4. Quick Check:

   Depends() needs function argument [OK]

Hint: Depends() always needs a function inside [OK]

Common Mistakes:

• Using Depends() without argument
• Expecting Depends() to work without function
• Confusing Depends() with decorator syntax

5. You want to share a database session dependency across multiple routes but also ensure it closes after each request. Which approach correctly uses shared dependencies with cleanup in FastAPI?

hard

A. Create the session globally once and reuse it without closing

B. Use a dependency function with yield that creates the session, yields it, then closes it after

C. Pass the session as a normal parameter without Depends()

D. Use Depends() but close the session manually inside each route

Solution

1. Step 1: Understand dependency cleanup

   FastAPI supports dependencies with cleanup by using yield inside the dependency function. This allows setup before yield and cleanup after.

2. Step 2: Apply to database session

   The correct pattern is to create the session, yield it for use in routes, then close it after the request finishes.

3. Final Answer:

   Use a dependency function with yield that creates the session, yields it, then closes it after -> Option B

4. Quick Check:

   Yield in dependency = setup and cleanup [OK]

Hint: Use yield in dependency for setup and cleanup [OK]

Common Mistakes:

• Reusing global session without closing
• Closing session inside route instead of dependency
• Not using Depends() for session injection