@fastify/caching 9.0.2 → 9.0.4

package/.github/dependabot.yml

@@ -2,12 +2,52 @@ version: 2
 updates:
   - package-ecosystem: "github-actions"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
     open-pull-requests-limit: 10
 
   - package-ecosystem: "npm"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
       interval: "weekly"
+    cooldown:
+      default-days: 7
+    versioning-strategy: "increase-if-necessary"
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
+    ignore:
+      # TODO: remove ignore until neostandard support ESLint 10
+      - dependency-name: "eslint"
+      - dependency-name: "neostandard"
+      - dependency-name: "@stylistic/*"
     open-pull-requests-limit: 10
+    groups:
+      # Production dependencies with breaking changes
+      dependencies:
+        dependency-type: "production"
+      # ESLint related dependencies
+      dev-dependencies-eslint:
+        patterns:
+          - "eslint"
+          - "neostandard"
+          - "@stylistic/*"
+      # TypeScript related dependencies
+      dev-dependencies-typescript:
+        patterns:
+          - "@types/*"
+          - "tstyche"
+          - "typescript"

package/.github/workflows/ci.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches:
      - main
-     - master
      - next
      - 'v*'
     paths-ignore:
@@ -15,9 +14,20 @@ on:
       - 'docs/**'
       - '*.md'
 
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+    group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
+    cancel-in-progress: true
+
+permissions:
+  contents: read
+
 jobs:
   test:
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
+    permissions:
+      contents: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@ef591e2186785d5ab36b9fe6a79c7ce2f1d94e57 # v7.0.0
     with:
       license-check: true
       lint: true

package/.github/workflows/lock-threads.yml

@@ -0,0 +1,19 @@
+name: Lock Threads
+
+on:
+  schedule:
+    - cron: '0 0 1 * *'
+  workflow_dispatch:
+
+concurrency:
+  group: lock
+
+permissions:
+  contents: read
+
+jobs:
+  lock-threads:
+    permissions:
+      issues: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/lock-threads.yml@ef591e2186785d5ab36b9fe6a79c7ce2f1d94e57 # v7.0.0

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2018 James Sumners <james.sumners@gmail.com>
+Copyright (c) 2018-present James Sumners <james.sumners@gmail.com>
+Copyright (c) 2018-present The Fastify team <https://github.com/fastify/fastify#team>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/{Readme.md → README.md}

@@ -1,15 +1,12 @@
 # @fastify/caching
 
-[![CI](https://github.com/fastify/fastify-caching/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/fastify/fastify-caching/actions/workflows/ci.yml)
+[![CI](https://github.com/fastify/fastify-caching/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/fastify-caching/actions/workflows/ci.yml)
 [![NPM version](https://img.shields.io/npm/v/@fastify/caching.svg?style=flat)](https://www.npmjs.com/package/@fastify/caching)
 [![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
 
-*@fastify/caching* is a plugin for the [Fastify](http://fastify.dev/) framework
+*@fastify/caching* is a plugin for the [Fastify](https://fastify.dev/) framework
 that provides server-side caching and mechanisms for manipulating HTTP cache headers according to
-[RFC 2616 §14.9](https://tools.ietf.org/html/rfc2616#section-14.9).
-
-Supports Fastify versions ^3.0.0. Version v5.x supports Fastify ^3.0.0 in
-the [`v5.x` branch](https://github.com/fastify/fastify-caching/tree/v5.x).
+[RFC 2616 §14.9](https://datatracker.ietf.org/doc/html/rfc2616#section-14.9).
 
 This plugin fully supports Fastify's encapsulation. Therefore, routes that
 should have differing cache settings should be registered within different
@@ -19,14 +16,33 @@ In addition to providing header manipulation, the plugin also decorates the
 server instance with an object that can be used for caching items. **Note:**
 the default cache should not be used in a "production" environment. It is
 an LRU, in-memory cache that is capped at 100,000 items. It is *highly*
-recommended that a full featured cache object be supplied, e.g.
+recommended that a full-featured cache object be supplied, e.g.
 [abstract-cache-redis][acache-redis].
 
 [acache-redis]: https://www.npmjs.com/package/abstract-cache-redis
 
+## Install
+```
+npm i @fastify/caching
+```
+
+### Compatibility
+| Plugin version | Fastify version |
+| ---------------|-----------------|
+| `>=9.x`        | `^5.x`          |
+| `^8.x`         | `^4.x`          |
+| `>=6.x <8.x`   | `^3.x`          |
+| `>=4.x <6.x`   | `^2.x`          |
+| `>=1.x <4.x`   | `^1.x`          |
+
+
+Please note that if a Fastify version is out of support, then so are the corresponding versions of this plugin
+in the table above.
+See [Fastify's LTS policy](https://github.com/fastify/fastify/blob/main/docs/Reference/LTS.md) for more details.
+
 ## Example
 
-This example shows using the plugin to disable client side caching of all
+This example shows using the plugin to disable client-side caching of all
 routes.
 
 ```js
@@ -107,7 +123,7 @@ for a *cache-response-directive* as defined by RFC 2616.
 resource may be cached. When this is set, and `privacy` is not set to `no-cache`,
 then `', max-age=<value>'` will be appended to the `cache-control` header.
 + `cache` (Default: `abstract-cache.memclient`): an [abstract-cache][acache]
-protocol compliant cache object. Note: the plugin requires a cache instance to
+protocol-compliant cache object. Note: the plugin requires a cache instance to
 properly support the ETag mechanism. Therefore, if a falsy value is supplied
 the default will be used.
 + `cacheSegment` (Default: `'@fastify/caching'`): segment identifier to use when
@@ -128,7 +144,7 @@ recommended to always supply a value to this method to avoid this operation.
 All incoming requests to paths affected by this plugin will be inspected for
 the `if-none-match` header. If the header is present, the value will be used
 to lookup the tag within the cache associated with this plugin. If the tag is
-found, then the response will be ended with a 304 status code sent to
+found, then the response will end with a 304 status code sent to
 the client.
 
 Tags will be cached according to the second parameter. If the second parameter
@@ -142,11 +158,11 @@ milliseconds. The default lifetime, when the parameter is not specified, is
 ### `reply.expires(date)`
 
 This method allows setting of the `expires` header. It accepts a regular `Date`
-object, or a string that is a valid date string according to
+object or a string that is a valid date string according to
 [RFC 2616 §14.21][sec14.21].
 
-[sec14.21]: https://tools.ietf.org/html/rfc2616#section-14.21
+[sec14.21]: https://datatracker.ietf.org/doc/html/rfc2616#section-14.21
 
 ## License
 
-[MIT License](https://jsumners.mit-license.org/)
+Licensed under [MIT](./LICENSE).

package/index.js

@@ -38,7 +38,7 @@ function cachingLoadByEtag (req, res, next) {
   })
 }
 
-function cachingStoreByEtag (req, res, payload, next) {
+function cachingStoreByEtag (_req, res, payload, next) {
   const etag = res.getHeader('etag')
   if (!etag || !res._etagLife) return next()
   this.cache.set(
@@ -60,7 +60,7 @@ function fastifyCaching (instance, options, next) {
   if (!_options.cache) _options.cache = abstractCache()
 
   if (_options.privacy) {
-    // https://tools.ietf.org/html/rfc2616#section-14.9.4
+    // https://datatracker.ietf.org/doc/html/rfc2616#section-14.9.4
     let value = _options.privacy
     if (_options.privacy.toLowerCase() !== 'no-cache' && _options.expiresIn) {
       value = `${_options.privacy}, max-age=${_options.expiresIn}`
@@ -70,9 +70,16 @@ function fastifyCaching (instance, options, next) {
       value += `, s-maxage=${_options.serverExpiresIn}`
     }
 
-    instance.addHook('onRequest', function cachingSetCacheControlHeader (req, res, next) {
-      if (!res.hasHeader('Cache-control')) {
-        res.header('Cache-control', value)
+    instance.addHook('onSend', function cachingSetCacheControlHeader (_req, reply, _payload, next) {
+      if (!reply.hasHeader('Cache-control')) {
+        // Only apply the caching value to successful (2xx) responses.
+        // Error responses must not be cached, otherwise browsers may serve
+        // a stale 4xx/5xx for the duration of max-age.
+        if (reply.statusCode >= 200 && reply.statusCode < 300) {
+          reply.header('Cache-control', value)
+        } else {
+          reply.header('Cache-control', 'no-store')
+        }
       }
       next()
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/caching",
-  "version": "9.0.2",
+  "version": "9.0.4",
   "description": "A plugin for Fastify to enable management of cache control headers",
   "main": "index.js",
   "type": "commonjs",
@@ -9,18 +9,14 @@
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
-    "test:typescript": "tsd",
+    "test:typescript": "tstyche",
     "test:unit": "c8 --100 node --test",
     "test:unit:report": "npm run test:unit -- --coverage-report=html",
     "test:unit:verbose": "npm run test:unit -- -Rspec"
   },
-  "precommit": [
-    "lint",
-    "test"
-  ],
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/fastify/fastify-caching.git"
+    "url": "git+https://github.com/fastify/fastify-caching.git"
   },
   "keywords": [
     "fastify",
@@ -28,29 +24,54 @@
     "caching"
   ],
   "author": "James Sumners <james.sumners@gmail.com>",
+  "contributors": [
+    {
+      "name": "Matteo Collina",
+      "email": "hello@matteocollina.com"
+    },
+    {
+      "name": "Manuel Spigolon",
+      "email": "behemoth89@gmail.com"
+    },
+    {
+      "name": "Aras Abbasi",
+      "email": "aras.abbasi@gmail.com"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    }
+  ],
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/fastify/fastify-caching/issues"
   },
   "homepage": "https://github.com/fastify/fastify-caching#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
   "devDependencies": {
-    "@fastify/pre-commit": "^2.1.0",
-    "@types/node": "^22.0.0",
-    "c8": "^10.1.2",
+    "@types/node": "^26.0.1",
+    "c8": "^12.0.0",
+    "eslint": "^9.17.0",
     "fastify": "^5.0.0",
-    "neostandard": "^0.11.9",
-    "tsd": "^0.31.0"
+    "neostandard": "^0.13.0",
+    "tstyche": "^7.0.0"
   },
   "dependencies": {
     "abstract-cache": "^1.0.1",
-    "fastify-plugin": "^5.0.0",
+    "fastify-plugin": "^6.0.0",
     "uid-safe": "^2.1.5"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "pre-commit": [
-    "lint",
-    "test"
-  ]
+  }
 }

package/test/cache.test.js

@@ -21,25 +21,25 @@ test('cache is usable', async (t) => {
   t.plan(4)
 
   const fastify = Fastify()
-  await fastify.register(async (instance, options) => {
-    instance.addHook('onRequest', async function checkCachingRegistered (req, reply) {
+  await fastify.register(async (instance) => {
+    instance.addHook('onRequest', async function checkCachingRegistered () {
       t.assert.ifError(instance[Symbol.for('fastify-caching.registered')])
     })
   })
   await fastify.register(plugin)
 
-  fastify.addHook('onRequest', async function checkCachingRegistered (req, reply) {
+  fastify.addHook('onRequest', async function checkCachingRegistered () {
     t.assert.strictEqual(this[Symbol.for('fastify-caching.registered')], true)
   })
 
-  fastify.get('/one', (req, reply) => {
+  fastify.get('/one', (_req, reply) => {
     fastify.cache.set('one', { one: true }, 1000, (err) => {
       if (err) return reply.send(err)
       reply.redirect('/two')
     })
   })
 
-  fastify.get('/two', (req, reply) => {
+  fastify.get('/two', (_req, reply) => {
     fastify.cache.get('one', (err, obj) => {
       t.assert.ifError(err)
       t.assert.strictEqual(obj.item, { one: true })
@@ -70,25 +70,25 @@ test('cache is usable with function as plugin default options input', async (t)
   t.plan(4)
 
   const fastify = Fastify()
-  await fastify.register(async (instance, options) => {
-    instance.addHook('onRequest', async function checkCachingNotRegistered (req, reply) {
+  await fastify.register(async (instance) => {
+    instance.addHook('onRequest', async function checkCachingNotRegistered () {
       t.assert.failure(instance[Symbol.for('fastify-caching.registered')])
     })
   })
   await fastify.register(plugin, () => () => {})
 
-  fastify.addHook('onRequest', async function checkCachingRegistered (req, reply) {
+  fastify.addHook('onRequest', async function checkCachingRegistered () {
     t.assert.strictEqual(this[Symbol.for('fastify-caching.registered')], true)
   })
 
-  fastify.get('/one', (req, reply) => {
+  fastify.get('/one', (_req, reply) => {
     fastify.cache.set('one', { one: true }, 1000, (err) => {
       if (err) return reply.send(err)
       reply.redirect('/two')
     })
   })
 
-  fastify.get('/two', (req, reply) => {
+  fastify.get('/two', (_req, reply) => {
     fastify.cache.get('one', (err, obj) => {
       t.assert.ifError(err)
       t.assert.strictEqual(obj.item, { one: true })
@@ -120,21 +120,21 @@ test('getting cache item with error returns error', async (t) => {
   t.plan(1)
 
   const mockCache = {
-    get: (info, callback) => callback(new Error('cache.get always errors')),
-    set: (key, value, ttl, callback) => callback()
+    get: (_info, callback) => callback(new Error('cache.get always errors')),
+    set: (_key, _value, _ttl, callback) => callback()
   }
 
   const fastify = Fastify()
   await fastify.register(plugin, { cache: mockCache })
 
-  fastify.get('/one', (req, reply) => {
+  fastify.get('/one', (_req, reply) => {
     fastify.cache.set('one', { one: true }, 1000, (err) => {
       if (err) return reply.send(err)
       return reply.etag('123456').send({ hello: 'world' })
     })
   })
 
-  fastify.get('/two', (req, reply) => {
+  fastify.get('/two', () => {
     fastify.cache.get('one', (err, obj) => {
       t.assert.failure(err)
       t.assert.failure(obj)
@@ -164,7 +164,7 @@ test('etags get stored in cache', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin)
 
-  fastify.get('/one', (req, reply) => {
+  fastify.get('/one', (_req, reply) => {
     reply.etag('123456').send({ hello: 'world' })
   })
 
@@ -191,7 +191,7 @@ test('etag cache life is customizable', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin)
 
-  fastify.get('/one', function (req, reply) {
+  fastify.get('/one', function (_req, reply) {
     reply
       // We set a cache lifetime of 50 milliseconds
       .etag('123456', 50)
@@ -237,7 +237,7 @@ test('returns response payload', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin)
 
-  fastify.get('/one', (req, reply) => {
+  fastify.get('/one', (_req, reply) => {
     reply.etag('123456', 300).send({ hello: 'world' })
   })
 

package/test/headers.test.js

@@ -10,7 +10,7 @@ test('decorators get added', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     t.assert.ok(reply.etag)
     reply.send()
   })
@@ -31,7 +31,7 @@ test('decorators add headers', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.etag(tag).send()
   })
 
@@ -51,7 +51,7 @@ test('sets etag header for falsy argument', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.etag().send()
   })
 
@@ -70,7 +70,7 @@ test('sets no-cache header', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, { privacy: plugin.privacy.NOCACHE })
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -95,7 +95,7 @@ test('sets private with max-age header', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, opts)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -124,7 +124,7 @@ test('sets public with max-age and s-maxage header', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, opts)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -151,12 +151,12 @@ test('do not set headers if another upstream plugin already sets it', async (t)
   }
 
   const fastify = Fastify()
-  fastify.addHook('onRequest', async function checkCachingDoesNotOverrideCacheControlHeader (req, reply) {
+  fastify.addHook('onRequest', async function checkCachingDoesNotOverrideCacheControlHeader (_req, reply) {
     reply.header('cache-control', 'do not override')
   })
   await fastify.register(plugin, opts)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -182,7 +182,7 @@ test('only sets max-age and ignores s-maxage with private header', async (t) =>
   const fastify = Fastify()
   await fastify.register(plugin, opts)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -210,7 +210,7 @@ test('s-maxage is optional with public header', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, opts)
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -230,7 +230,7 @@ test('sets no-store with max-age header', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, { privacy: 'no-store', expiresIn: 300 })
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.send({ hello: 'world' })
   })
 
@@ -247,6 +247,105 @@ test('sets no-store with max-age header', async (t) => {
   )
 })
 
+test('does not cache 5xx error responses', async (t) => {
+  t.plan(2)
+
+  const opts = {
+    privacy: plugin.privacy.PRIVATE,
+    expiresIn: 300
+  }
+
+  const fastify = Fastify()
+  await fastify.register(plugin, opts)
+
+  fastify.get('/', () => {
+    throw new Error('kaboom')
+  })
+
+  await fastify.ready()
+
+  const response = await fastify.inject({
+    method: 'GET',
+    path: '/'
+  })
+  t.assert.strictEqual(response.statusCode, 500)
+  t.assert.strictEqual(response.headers['cache-control'], 'no-store')
+})
+
+test('does not cache 4xx error responses', async (t) => {
+  t.plan(2)
+
+  const opts = {
+    privacy: plugin.privacy.PRIVATE,
+    expiresIn: 300
+  }
+
+  const fastify = Fastify()
+  await fastify.register(plugin, opts)
+
+  fastify.get('/', (_req, reply) => {
+    reply.code(400).send({ error: 'bad request' })
+  })
+
+  await fastify.ready()
+
+  const response = await fastify.inject({
+    method: 'GET',
+    path: '/'
+  })
+  t.assert.strictEqual(response.statusCode, 400)
+  t.assert.strictEqual(response.headers['cache-control'], 'no-store')
+})
+
+test('does not cache framework 404 responses', async (t) => {
+  t.plan(2)
+
+  const opts = {
+    privacy: plugin.privacy.PRIVATE,
+    expiresIn: 300
+  }
+
+  const fastify = Fastify()
+  await fastify.register(plugin, opts)
+
+  await fastify.ready()
+
+  const response = await fastify.inject({
+    method: 'GET',
+    path: '/does-not-exist'
+  })
+  t.assert.strictEqual(response.statusCode, 404)
+  t.assert.strictEqual(response.headers['cache-control'], 'no-store')
+})
+
+test('does not override a Cache-control header set upstream on error responses', async (t) => {
+  t.plan(2)
+
+  const opts = {
+    privacy: plugin.privacy.PRIVATE,
+    expiresIn: 300
+  }
+
+  const fastify = Fastify()
+  fastify.addHook('onRequest', async function presetCacheControl (_req, reply) {
+    reply.header('cache-control', 'private, max-age=10')
+  })
+  await fastify.register(plugin, opts)
+
+  fastify.get('/', () => {
+    throw new Error('kaboom')
+  })
+
+  await fastify.ready()
+
+  const response = await fastify.inject({
+    method: 'GET',
+    path: '/'
+  })
+  t.assert.strictEqual(response.statusCode, 500)
+  t.assert.strictEqual(response.headers['cache-control'], 'private, max-age=10')
+})
+
 test('sets the expires header', async (t) => {
   t.plan(2)
 
@@ -255,7 +354,7 @@ test('sets the expires header', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, { privacy: plugin.privacy.NOCACHE })
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.expires(now).send({ hello: 'world' })
   })
 
@@ -275,7 +374,7 @@ test('sets the expires header to a falsy value', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, { privacy: plugin.privacy.NOCACHE })
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.expires().send({ hello: 'world' })
   })
 
@@ -294,7 +393,7 @@ test('sets the expires header to a custom value', async (t) => {
   const fastify = Fastify()
   await fastify.register(plugin, { privacy: plugin.privacy.NOCACHE })
 
-  fastify.get('/', (req, reply) => {
+  fastify.get('/', (_req, reply) => {
     reply.expires('foobar').send({ hello: 'world' })
   })
 

package/types/index.d.ts

@@ -1,5 +1,3 @@
-/// <reference types='node' />
-
 import { FastifyPluginCallback } from 'fastify'
 
 declare module 'fastify' {

package/types/index.tst.ts

@@ -0,0 +1,68 @@
+import Fastify, { FastifyReply } from 'fastify'
+import { expect } from 'tstyche'
+import fastifyCaching, {
+  AbstractCacheCompliantObject,
+  FastifyCachingPluginOptions,
+} from '..'
+
+const fastify = Fastify({ logger: true })
+
+const cachingOptions: FastifyCachingPluginOptions = {
+  privacy: fastifyCaching.privacy.PUBLIC,
+  expiresIn: 300,
+  cacheSegment: 'fastify-caching',
+}
+expect(cachingOptions).type.toBeAssignableTo<FastifyCachingPluginOptions>()
+
+fastify.register(fastifyCaching, cachingOptions)
+
+expect(fastify.cache).type.toBe<AbstractCacheCompliantObject>()
+expect(fastify.cache.get).type.toBe<AbstractCacheCompliantObject['get']>()
+expect(fastify.cache.set).type.toBe<AbstractCacheCompliantObject['set']>()
+expect(fastify.cacheSegment).type.toBe<string>()
+
+fastify.get('/one', async (_request, reply) => {
+  expect(reply.etag).type.toBe<(tag?: string, timeToLive?: number) => FastifyReply>()
+  expect(reply.expires).type.toBe<(date?: Date) => FastifyReply>()
+
+  expect(reply.etag('hello', 6000)).type.toBe<FastifyReply>()
+  expect(reply.expires(new Date(Date.now() + 6000))).type.toBe<FastifyReply>()
+
+  return { message: 'one' }
+})
+
+fastify.get('/two', async (_request, reply) => {
+  expect(
+    reply.etag('hello', 6000).expires(new Date(Date.now() + 6000))
+  ).type.toBe<FastifyReply>()
+
+  return { message: 'two' }
+})
+
+// We register a new instance that should trigger a typescript error.
+const shouldErrorApp = Fastify({ logger: true })
+
+const badCachingOptions = {
+  privacy: fastifyCaching.privacy.PRIVATE,
+  expiresIn: 'a string instead of a number of second',
+  cacheSegment: 'fastify-caching',
+}
+
+expect(shouldErrorApp.register).type.not.toBeCallableWith(fastifyCaching, badCachingOptions)
+
+fastify.get('/three', async () => {
+  expect(fastify.cache.get('well-known')).type.toBeAssignableTo<Promise<unknown>>()
+
+  expect(fastify.cache.get<string>('well-known')).type.toBe<
+    Promise<{ item: string; stored: number; ttl: number; } | null>
+  >()
+
+  const result = fastify.cache.get<string>('well-known', (err, value) => {
+    expect(err).type.toBe<unknown>()
+    expect(value).type.toBe<{ item: string; stored: number; ttl: number; } | null>()
+  })
+
+  expect(result).type.toBe<void>()
+
+  return { message: 'two' }
+})

package/.github/stale.yml

@@ -1,21 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 15
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 7
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - "discussion"
-  - "feature request"
-  - "bug"
-  - "help wanted"
-  - "plugin suggestion"
-  - "good first issue"
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false

package/types/index.test-d.ts

@@ -1,69 +0,0 @@
-import Fastify, { FastifyReply } from 'fastify'
-import { expectAssignable, expectError, expectType } from 'tsd'
-import fastifyCaching, {
-  AbstractCacheCompliantObject,
-  FastifyCachingPluginOptions,
-} from '..'
-
-const fastify = Fastify({ logger: true })
-
-const cachingOptions: FastifyCachingPluginOptions = {
-  privacy: fastifyCaching.privacy.PUBLIC,
-  expiresIn: 300,
-  cacheSegment: 'fastify-caching',
-}
-expectAssignable<FastifyCachingPluginOptions>(cachingOptions)
-
-fastify.register(fastifyCaching, cachingOptions)
-
-expectType<AbstractCacheCompliantObject>(fastify.cache)
-expectType<AbstractCacheCompliantObject['get']>(fastify.cache.get)
-expectType<AbstractCacheCompliantObject['set']>(fastify.cache.set)
-expectType<string>(fastify.cacheSegment)
-// expectType<number>(fastify.etagMaxLife);
-
-fastify.get('/one', async (request, reply) => {
-  expectType<(tag?: string, timeToLive?: number) => FastifyReply>(reply.etag)
-  expectType<(date?: Date) => FastifyReply>(reply.expires)
-
-  expectType<FastifyReply>(reply.etag('hello', 6000))
-  expectType<FastifyReply>(reply.expires(new Date(Date.now() + 6000)))
-
-  return { message: 'one' }
-})
-
-fastify.get('/two', async (request, reply) => {
-  expectType<FastifyReply>(
-    reply.etag('hello', 6000).expires(new Date(Date.now() + 6000))
-  )
-
-  return { message: 'two' }
-})
-
-// We register a new instance that should trigger a typescript error.
-const shouldErrorApp = Fastify({ logger: true })
-
-const badCachingOptions = {
-  privacy: fastifyCaching.privacy.PRIVATE,
-  expiresIn: 'a string instead of a number of second',
-  cacheSegment: 'fastify-caching',
-}
-
-expectError(shouldErrorApp.register(fastifyCaching, badCachingOptions))
-
-fastify.get('/three', async (request, reply) => {
-  expectAssignable<Promise<unknown>>(
-    fastify.cache.get('well-known')
-  )
-  expectAssignable<Promise<{ item: string; stored: number; ttl: number; } | null>>(
-    fastify.cache.get<string>('well-known')
-  )
-  expectType<void>(
-    fastify.cache.get<string>('well-known', (err, value) => {
-      expectType<unknown>(err)
-      expectAssignable<{ item: string; stored: number; ttl: number; } | null>(value)
-    })
-  )
-
-  return { message: 'two' }
-})