Global middleware per Router?

[Vesafary]

Let's say I have multiple Routers to split routes, is it possible to give each router its own global middleware?

Right now, in my test setup, it seems like they are all piled together:

# Sketch setup

class TestMiddleware(BaseMiddlewareHandler):
    def __init__(self):
        super().__init__()

    def handler(self, app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
        print("Hello from middleware")
        return next_middleware(app)


router = Router()
router.use(middlewares=[
    TestMiddleware(), 
])
router2 = Router()

app = APIGatewayRestResolver(debug=True)
app.include_router(router)
app.include_router(router2)

@router2.get(f"/test/")  # Would not expect any middleware being called here
def func():
    return "Ok"




# Processing Route:::func (/test/)
#
# Middleware Stack:
# =================
# TestMiddleware
# =================

[leandrodamascena]

Hey @Vesafary! Unfortunately, you cannot use individual middlewares per Router class because when you use app.include_router(), it merges all existing middlewares into the app instance and executes all of them. What you can have is a middleware per operation, like in this example: https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/#middleware.

I'm interested in understanding the use case for why you need middleware per Router. Perhaps you are organizing your routes based on a specific logic, such as domain/entities/others, and you would like to apply the same Middleware to all routes in this case?

[Vesafary]

Hi @leandrodamascena! Thanks for your answer.

There's a couple of reasons. The most important one to us: our application has a role-based authentication system (which is primarily handled by an API Gateway Authoriser), but a couple of endpoints have either role-based logic (e.g. an admin would fetch more (deleted) objects than a normal user) or instance-based logic (e.g. only the creator of an item is able to see it, or when the creator decides to share it). In these cases, a gateway authoriser can't do much more than accept the request, and the authentication has to be handled by the backend. This is what we're trying to do with a middleware, but to avoid someone forgetting to add it to a route (as per your example), or setting the wrong one, and to avoid code duplication and upon a refactor having to change dozens of endpoints, we want to add it globally as a "default" instead of on a per endpoint basis. However, that runs into the issue that some requests (e.g. OPTIONS, /swagger, some custom ones) have to be open-access. In my opinion, the nicest and easiest solution was to use multiple routers.

BTW, as a follow-up it would also be nice if we could nest routers. Right now, you can only include a router on the app-level with a prefix, but not on another one. Usecase for this would be even further separation and less repetition between multiple domains.
For instance, I could have a router per domain (/posts, /users, etc), and then have a router without middleware and one with, where I could do something like middleware_router.use(middlewares=[...]).include_router(post_router).include_router(user_router) and not have the middleware defined on both the post_router and user_router.