fix: unsafe methods not causing cache purge

lib/handler/cache-handler.js

@@ -16,11 +16,6 @@ class CacheHandler extends DecoratorHandler {
    */
   #store
 
-  /**
-   * @type {import('../../types/cache-interceptor.d.ts').default.CacheMethods}
-   */
-  #methods
-
   /**
    * @type {import('../../types/dispatcher.d.ts').default.RequestOptions}
    */
@@ -42,14 +37,13 @@ class CacheHandler extends DecoratorHandler {
    * @param {import('../../types/dispatcher.d.ts').default.DispatchHandlers} handler
    */
   constructor (opts, requestOptions, handler) {
-    const { store, methods } = opts
+    const { store } = opts
 
     super(handler)
 
     this.#store = store
     this.#requestOptions = requestOptions
     this.#handler = handler
-    this.#methods = methods
   }
 
   /**
@@ -75,7 +69,7 @@ class CacheHandler extends DecoratorHandler {
     )
 
     if (
-      !this.#methods.includes(this.#requestOptions.method) &&
+      !util.safeHTTPMethods.includes(this.#requestOptions.method) &&
       statusCode >= 200 &&
       statusCode <= 399
     ) {

lib/interceptor/cache.js

@@ -32,7 +32,7 @@ module.exports = (opts = {}) => {
 
   return dispatch => {
     return (opts, handler) => {
-      if (!opts.origin || !methods.includes(opts.method)) {
+      if (!opts.origin || (util.safeHTTPMethods.includes(opts.method) && !methods.includes(opts.method))) {
         // Not a method we want to cache or we don't have the origin, skip
         return dispatch(opts, handler)
       }

test/interceptors/cache.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { describe, test, after } = require('node:test')
-const { strictEqual, notEqual, fail } = require('node:assert')
+const { strictEqual, notEqual, fail, equal } = require('node:assert')
 const { createServer } = require('node:http')
 const { once } = require('node:events')
 const FakeTimers = require('@sinonjs/fake-timers')
@@ -250,4 +250,55 @@ describe('Cache Interceptor', () => {
       }
     })
   })
+
+  test('unsafe methods call the store\'s deleteByOrigin function', async () => {
+    const server = createServer((_, res) => {
+      res.end('asd')
+    }).listen(0)
+
+    after(() => server.close())
+    await once(server, 'listening')
+
+    let deleteByOriginCalled = false
+    const store = new cacheStores.MemoryCacheStore()
+
+    const originalDeleteByOrigin = store.deleteByOrigin.bind(store)
+    store.deleteByOrigin = (origin) => {
+      deleteByOriginCalled = true
+      originalDeleteByOrigin(origin)
+    }
+
+    const client = new Client(`http://localhost:${server.address().port}`)
+      .compose(interceptors.cache({
+        store,
+        methods: ['GET'] // explicitly only cache GET methods
+      }))
+
+    // Make sure safe methods that we want to cache don't cause a cache purge
+    await client.request({
+      origin: 'localhost',
+      method: 'GET',
+      path: '/'
+    })
+
+    equal(deleteByOriginCalled, false)
+
+    // Make sure other safe methods that we don't want to cache don't cause a cache purge
+    await client.request({
+      origin: 'localhost',
+      method: 'HEAD',
+      path: '/'
+    })
+
+    strictEqual(deleteByOriginCalled, false)
+
+    // Make sure unsafe methods cause a cache purge
+    await client.request({
+      origin: 'localhost',
+      method: 'DELETE',
+      path: '/'
+    })
+
+    equal(deleteByOriginCalled, true)
+  })
 })