return caching and ttl informations, short circuit with memoized cache

Author: dustin deus

src/http-data-source.ts

@@ -42,6 +42,9 @@ export type Request = UndiciRequestOptions &
 
 export type Response<TResult> = {
   body: TResult
+  memoized: boolean
+  isFromCache: boolean
+  maxTtl?: number
 } & Omit<ResponseData, 'body'>
 
 export interface LRUOptions {
@@ -257,14 +260,16 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
       }
 
       const response: Response<TResult> = {
+        isFromCache: false,
+        memoized: false,
         ...responseData,
         body: json,
       }
 
       this.onResponse<TResult>(options, response)
 
+      // let's see if we can fill the shared cache
       if (options.requestCache && this.isResponseCacheable<TResult>(options, response)) {
-        // TODO log errors with external logger
         this.storageAdapter
           .set(cacheKey, response, options.requestCache?.maxTtl)
           .catch((err) => this.logger?.error(err))
@@ -282,6 +287,8 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
           `staleIfError:${cacheKey}`,
         )
         if (hasFallback) {
+          hasFallback.isFromCache = true
+          hasFallback.maxTtl = options.requestCache.maxTtlIfError
           return hasFallback
         }
       }
@@ -296,29 +303,37 @@ export abstract class HTTPDataSource<TContext = any> extends DataSource {
     }
 
     const cacheKey = this.onCacheKeyCalculation(request)
-    const ttlCacheEnabled = request.requestCache
 
     // check if we have any GET call in the cache and respond immediatly
-    if (request.method === 'GET' && ttlCacheEnabled) {
-      const cachedResponse = await this.storageAdapter.get(cacheKey)
+    if (request.method === 'GET') {
+      // Memoize GET calls for the same data source instance
+      // a single instance of the data sources is scoped to one graphql request
+      const cachedResponse = this.memoizedResults.get(cacheKey)
       if (cachedResponse) {
+        cachedResponse.memoized = true
+        cachedResponse.isFromCache = false
         return cachedResponse
       }
+
+      // try to fetch from shared cache
+      if (request.requestCache) {
+        const cachedResponse: Response<TResult> = await this.storageAdapter.get(cacheKey)
+        if (cachedResponse) {
+          cachedResponse.memoized = false
+          cachedResponse.isFromCache = true
+          cachedResponse.maxTtl = request.requestCache.maxTtl
+          return cachedResponse
+        }
+      }
     }
 
     const options = {
       ...this.globalRequestOptions,
       ...request,
     }
 
-    // Memoize GET calls for the same data source instance
-    // a single instance of the data sources is scoped to one graphql request
+    // let's see if we can fill the memoized cache
     if (options.method === 'GET') {
-      const cachedResponse = this.memoizedResults.get(cacheKey)
-      if (cachedResponse) {
-        return cachedResponse
-      }
-
       const response = await this.performRequest<TResult>(options, cacheKey)
 
       if (this.isResponseCacheable<TResult>(options, response)) {

test/rest-data-source.test.ts

@@ -16,7 +16,7 @@ setGlobalDispatcher(agent)
 const test = anyTest as TestInterface<{ path: string }>
 
 test('Should be able to make a simple GET call', async (t) => {
-  t.plan(2)
+  t.plan(5)
 
   const path = '/'
 
@@ -46,6 +46,9 @@ test('Should be able to make a simple GET call', async (t) => {
 
   const response = await dataSource.getFoo()
 
+  t.false(response.isFromCache)
+  t.false(response.memoized)
+  t.falsy(response.maxTtl)
   t.deepEqual(response.body, { name: 'foo' })
 })
 
@@ -181,8 +184,8 @@ test('Should be able to pass query params', async (t) => {
         query: {
           a: 1,
           b: '2',
-          c: undefined
-        }
+          c: undefined,
+        },
       })
     }
   })()
@@ -230,7 +233,7 @@ test('Should error', async (t) => {
 })
 
 test('Should memoize subsequent GET calls to the same endpoint', async (t) => {
-  t.plan(5)
+  t.plan(17)
 
   const path = '/'
 
@@ -260,15 +263,27 @@ test('Should memoize subsequent GET calls to the same endpoint', async (t) => {
 
   let response = await dataSource.getFoo()
   t.deepEqual(response.body, { name: 'foo' })
+  t.false(response.isFromCache)
+  t.false(response.memoized)
+  t.falsy(response.maxTtl)
 
   response = await dataSource.getFoo()
   t.deepEqual(response.body, { name: 'foo' })
+  t.false(response.isFromCache)
+  t.true(response.memoized)
+  t.falsy(response.maxTtl)
 
   response = await dataSource.getFoo()
   t.deepEqual(response.body, { name: 'foo' })
+  t.false(response.isFromCache)
+  t.true(response.memoized)
+  t.falsy(response.maxTtl)
 
   response = await dataSource.getFoo()
   t.deepEqual(response.body, { name: 'foo' })
+  t.false(response.isFromCache)
+  t.true(response.memoized)
+  t.falsy(response.maxTtl)
 })
 
 test('Should be able to define a custom cache key for request memoization', async (t) => {
@@ -570,7 +585,7 @@ test('Initialize data source with cache and context', async (t) => {
 })
 
 test('Response is cached', async (t) => {
-  t.plan(6)
+  t.plan(16)
 
   const path = '/'
 
@@ -589,7 +604,7 @@ test('Response is cached', async (t) => {
 
   const baseURL = `http://localhost:${(server.address() as AddressInfo)?.port}`
 
-  const dataSource = new (class extends HTTPDataSource {
+  let dataSource = new (class extends HTTPDataSource {
     constructor() {
       super(baseURL)
     }
@@ -604,8 +619,7 @@ test('Response is cached', async (t) => {
   })()
 
   const map = new Map<string, string>()
-
-  dataSource.initialize({
+  const datasSourceConfig = {
     context: {
       a: 1,
     },
@@ -620,14 +634,42 @@ test('Response is cached', async (t) => {
         map.set(key, value)
       },
     },
-  })
+  }
 
-  let response = await dataSource.getFoo()
+  dataSource.initialize(datasSourceConfig)
 
+  let response = await dataSource.getFoo()
+  t.false(response.isFromCache)
+  t.false(response.memoized)
+  t.falsy(response.maxTtl)
   t.deepEqual(response.body, { name: 'foo' })
 
   response = await dataSource.getFoo()
+  t.false(response.isFromCache)
+  t.true(response.memoized)
+  t.falsy(response.maxTtl)
+  t.deepEqual(response.body, { name: 'foo' })
+
+  dataSource = new (class extends HTTPDataSource {
+    constructor() {
+      super(baseURL)
+    }
+    getFoo() {
+      return this.get(path, {
+        requestCache: {
+          maxTtl: 100,
+          maxTtlIfError: 200,
+        },
+      })
+    }
+  })()
+
+  dataSource.initialize(datasSourceConfig)
 
+  response = await dataSource.getFoo()
+  t.true(response.isFromCache)
+  t.false(response.memoized)
+  t.is(response.maxTtl, 100)
   t.deepEqual(response.body, { name: 'foo' })
 
   const cached = JSON.parse(map.get('keyv:' + baseURL + path)!)
@@ -650,7 +692,7 @@ test('Response is cached', async (t) => {
 })
 
 test('Fallback from cache on origin error', async (t) => {
-  t.plan(6)
+  t.plan(12)
 
   const path = '/'
 
@@ -711,6 +753,9 @@ test('Fallback from cache on origin error', async (t) => {
   dataSource.initialize(datasSourceConfig)
 
   let response = await dataSource.getFoo()
+  t.false(response.isFromCache)
+  t.false(response.memoized)
+  t.falsy(response.maxTtl)
 
   t.deepEqual(response.body, { name: 'foo' })
 
@@ -735,14 +780,17 @@ test('Fallback from cache on origin error', async (t) => {
   dataSource.initialize(datasSourceConfig)
 
   response = await dataSource.getFoo()
+  t.true(response.isFromCache)
+  t.false(response.memoized)
+  t.is(response.maxTtl, 200)
 
   t.deepEqual(response.body, { name: 'foo' })
 
   t.is(map.size, 1)
 })
 
 test('Should not cache POST requests', async (t) => {
-  t.plan(3)
+  t.plan(6)
 
   const path = '/'
 
@@ -796,6 +844,9 @@ test('Should not cache POST requests', async (t) => {
   })
 
   const response = await dataSource.postFoo()
+  t.false(response.isFromCache)
+  t.false(response.memoized)
+  t.falsy(response.maxTtl)
 
   t.deepEqual(response.body, { name: 'foo' })