Dependency Injection

FlaskNova provides a lightweight dependency mechanism for resolving simple values and services directly into route functions. Use Depend to keep application logic separate from request handling.

Why use Depend?

Keep route handlers concise and focused.
Inject authentication or authorization values cleanly.
Provide request-scoped utilities like loggers or caches.
Reuse shared service constructors without manual wiring.

Basic example

from flask_nova import Depend


def current_user(token: str = "secret"):
    return {"user": "alice", "roles": ["admin"]}


@app.get("/me")
def get_me(user=Depend(current_user)):
    return user

Request-scoped context

Every request gets a trace id stored on g.trace_id. This is useful for dependencies that need request-specific state or logging.

from flask import g
from flask_nova import Depend


def request_logger():
    return lambda message: print(f"[{g.trace_id}] {message}")


@app.get("/status")
def status(route_logger=Depend(request_logger)):
    route_logger("status requested")
    return {"trace_id": g.trace_id}

Lifetime patterns

Singleton

A single shared instance for the app lifetime. Useful for global services and caches.

cache = CacheClient()


def get_cache():
    return cache

app.config is an example

Scoped

Per-request dependencies are resolved for each request. FlaskNova makes it easy to access request-scoped values via Depend.

from flask import Depend
def user_current_user_id():
    return 123

@app.get("/user")
def user(user = Depend(user_current_user_id)):...

Transient

Create a fresh object every time the dependency is resolved. Use this for non-shared helpers or lightweight factories.

def new_service():
    return Service()

Best practices

Keep dependencies small and explicit. Use them for computed values, service resolution, and authorization checks, while keeping endpoint logic focused on request handling.