Middleware documentation about starlette

[jordaneremieff]

This is just a rough outline of something I have thought about before in regards to how an ASGI application could use a list of middleware passed to a main application. I've tailored it to a Starlette-like application because this how I would use it - curious if something along these lines (or any part of it) could work here:

class Starlette:
    def __init__(self, middlewares: Sequence[ASGIApp] = []) -> None:
        self.middlewares = middlewares

    def compose_middleware(self, app: ASGIApp, scope: Scope) -> ASGIApp:
        # Apply `self.middlewares` here
        # Perhaps something similar to how AuthMiddlewareStack works in channels?
        return app

    def add_middleware(self, app: ASGIApp) -> None:
        # For when we want to `app.add_middleware(middleware)`
        self.middlewares.append(app)

    def __call__(self, scope: Scope) -> ASGIInstance:
        scope["app"] = self
        return self.compose_middleware(app, scope)

If we could identify a robust means of composing any list of ASGI application middleware, then I'd imagine it would be flexible enough to do things like:

from somepackage import generic_middleware
from mypackage import my_middleware_middleware, my_other_middleware_specific_middleware

my_middleware = Starlette(
    middlewares=[my_middleware_middleware, my_other_middleware_specific_middleware]
)
app = Starlette(middlewares=[generic_middleware, my_middleware])

Obviously this is a strange example, but just wanted to illustrate the composability aspect.