Ability to define cached routes on CacheMiddleware

[florimondmanca]

@invokermain wrote in #22:

For my use case it would amazing to be able to specify routes for which a cache applies to when adding the middleware. Looking through the source code I cannot see why this would not be possible. I imagine the use could specify this by passing a list of routes, like: ['/api/y', '/api/x'] and anything that matches these routes is cached?

[florimondmanca]

@invokermain

Looking through the source code I cannot see why this would not be possible.

A general rule of thumb that I am applying for now is that this package should not perform any framework-specific integration, and this means sticking to only the information the ASGI spec gives us (e.g. in the scope dict). The main goal is to keep our scope as small as possible, in order to ultimately reduce maintenance overhead while providing an easy-to use and easy-to-extend caching solution for ASGI-based apps and frameworks.

But as it turns out, route pattern matching is very much a framework-specific feature.

Maybe in the most basic cases having asgi-caches read from a list of route paths would work (e.g. route_paths=["/", "/some/path"]).

But as soon as we want to add a notion of pattern matching ("cache all routes that look like this", e.g. using "/users/{user_id}"), then unless we want to re-implement a routing algorithm (and we don't), things start to get framework-specific.

Even then, there is no standard way to retrieve a matched route pattern from the ASGI scope, so I'm not even sure we'd be able to integrate with Starlette.

So I think what should ultimetaly prevail here is modularity and separation of concerns, which is why I don't think such a feature should land in this package itself.

---

Now, on the bright side, Starlette v0.13+ does provide a declarative approach in which users theoretically tie into if they'd like a more declarative caching approach. (We'll need to udpate the docs to reflect this new style that Starlette is now encouraging.)

This style would even remove the need for the @cached decorator (at least for Starlette apps), because all it allows to do is apply CacheMiddleware onto an endpoint using the decorator syntax.

So, although the following may look a bit jarring, it should work, even as of 0.3.0:

from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.routing import Route
from starlette.endpoints import HTTPEndpoint
from starlette.responses import PlainTextResponse
from async_caches import Cache
from asgi_caches.middleware import CacheMiddleware

from . import sub  # Example

cache = Cache("locmem://null")

class Home(HTTPEndpoint):
    async def get(self, request):
        return PlainTextResponse("Hello, world!")

routes = [
    Route("/", CacheMiddleware(Home, cache=cache)),
    Mount("/sub-app", CacheMiddleware(sub.app, cache=cache)),
]

app = Starlette(routes=routes)

Here, we can visually see that all routes wrapped in CacheMiddleware are cached. And this doesn't require us to make any assumption on how Starlette works.