[RESTDataSource]: allow per-request caching logic

[bennypowers]

RESTDataSource caches each GET request, and clears the cache for other HTTP verbs. Most of the time this is exactly what users need. However there are cases where users need to cache POST requests as if they were query-style requests, for example, if they are POSTing a graphql query, or if the resource they are requesting accepts POST bodies as configuration for some computation. In these cases, users would like to configure the caching behaviour on a per-request basis.

API Proposal

class MyDataSource extends RESTDataSource<MyContext> {
  /** @override */
  protected checkRequestCache<T = any>(
    request: Request,
    cacheKey: string,
    performRequest: () => Promise<T>,
  ): Promise<T> {
    if (request.url.includes('/my-posty-query-endpoint')) {
      let promise = this.memoizedResults.get(cacheKey);
      if (promise) return promise;
      promise = performRequest();
      this.memoizedResults.set(cacheKey, promise);
      return promise;
    } else {
      return super.checkRequestCache(request, cacheKey, performRequest);
    }
  }
}

Absent this feature, the user will have to override the entire fetch method, when she really only wants to modify the last 1/5 of its code. Moreover, fetch is private and can't be overridden, so users with this case seemingly have no recourse.

---

Alternate API Proposal

base class

class RESTDataSource {
  private async fetch<TResult>(
    init: RequestInit & {
      path: string;
      params?: URLSearchParamsInit;
    },
  ): Promise<TResult> {
    // ... yadda yadda ...
  
    const performRequest = async () => { /* ... */ };
  
    if (this.shouldCacheRequest(request)) {
      return this.cacheRequest(cacheKey, performRequest)
    } else {
      this.memoizedResults.delete(cacheKey);
      return performRequest();
    }
  }
  
  /** Override to configure caching behaviour per request */
  protected shouldCacheRequest(request: Request): boolean {
    return request.method === 'GET';
  }
  
  private cacheRequest<T = any>(cacheKey: string, performRequest: () => Promise<T>): Promise<T> {
    let promise = this.memoizedResults.get(cacheKey);
    if (promise) return promise;
  
    promise = performRequest();
    this.memoizedResults.set(cacheKey, promise);
    return promise;
  }
}

Usage:

protected shouldCacheRequest(request: Request): boolean {
  const { pathname } = new URL(request.url);
  switch (pathname) {
    case '/query-post':
    case '/definitely-cache-this':
      return true;
    default:
      return request.method === 'GET';
  }
}