issue_comments

This looks relevant:

https://pluggy.readthedocs.io/en/stable/#wrappers

A hookimpl can be marked with the "wrapper" option, which indicates that the function will be called to wrap (or surround) all other normal hookimpl calls. A hook wrapper can thus execute some code ahead and after the execution of all corresponding non-wrappper hookimpls.

This could be the perfect mechanism for implementing this hook, although I still need to figure out how it interacts with streaming.

Need to make sure the design of this takes streaming responses into account. Those could be pretty tricky here.

I nice thing about asgi_wrapper() is that it handles those already.

The hook could be called register_middleware() and could work like register_routes() and register_commands():

```python @hookspec def register_middleware(datasette): """Register middleware: returns a list of async def middleware functions"""

```

A pattern like this could be interesting: python async def my_middleware(datasette, request, get_response): # Mess with request here if neccessary response = await get_response(request) # mess with response return response The Django pattern is more complicated but does have that mechanism for running one-time configuration prior to defining the middleware() function, which is neat.

This could even be a pair of hooks - process_request() and process_response().

Or could take a leaf from Django, which redesigned middleware to use this pattern instead:

python def simple_middleware(get_response): # One-time configuration and initialization. def middleware(request): # Code to be executed for each request before # the view (and later middleware) are called. response = get_response(request) # Code to be executed for each request/response after # the view is called. return response return middleware Or even borrow an idea from pytest where fixtures can yield in the middle, like this: python @pytest.fixture def sending_user(mail_admin): user = mail_admin.create_user() yield user mail_admin.delete_user(user)

Not sure what to call this. Maybe app_wrapper()?

Or perhaps it's simpler than that, something like this:

python @hookspec def process_response(datasette, request, response): """Last chance to modify the response before it is returned to the client"""