Feature request: Make Dependency Injection work for Middleware

[bdellegrazie]

Use case

Hi,

Is there a way to extend the Dependency Injection support for routes to include middleware functions as well? Is this worthwhile?

Middleware is typically used to augment a request with additional data or implement a strict control and this is something that might require data access object (DAO) patterns or similar.

Thoughts?

Thanks in advance,

Brett

Solution/User Experience

Example :

Obviously this is a contrived example. As per the framework it would be possible to return an error response if any lookup failed rather than continuing on as this example does.

def user_middleware(
    app: APIGatewayHttpResolver,
    next_middleware: NextMiddleware,
    user_dao: Annotated[UserDao, Depends(get_user_dao)],
) -> Response:
    authorizer = app.current_event.request_context.authorizer
    if authorizer:
        sub: str | None = app.current_event.request_context.authorizer.jwt_claim.get("sub")
        if sub:
            user = user_dao.get(sub)
            if user:
                app.append_context(user=user)
    return next_middleware(app)

Alternative solutions

Acknowledgment

• This feature request meets Powertools for AWS Lambda (Python) Tenets
• Should this be considered in other Powertools for AWS Lambda languages? i.e. Java, TypeScript, and .NET

[leandrodamascena]

Hey @bdellegrazie, sorry for taking so long to come back to this.

Yes, I think this is worthwhile. We already support middleware writing data to app.context and a route dependency reading it through Request.context, but that does not cover your example. If the middleware itself needs a DAO, Depends() is a much better fit than creating and wiring it manually.

There is one important detail in the implementation: middleware and route dependencies must share the same cache for the request. Otherwise, a dependency used by both would run twice even with use_cache=True.

I would expect this to support:

• dependency_overrides;
• Request injection;
• sync and async middleware;
• middleware short-circuiting without resolving the route dependencies;
• the same dependency being resolved only once across middleware and route.

I would start with function-based middleware. Class-based middleware needs a little more thought because we need to decide whether dependencies belong to __call__ or handler().

Thanks for bringing this up and for including a clear example. I’m marking this as accepted.