@fastify/caching 9.0.3 → 9.0.5

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/.github/workflows/release.yml

@@ -0,0 +1,24 @@
+name: Release the package
+
+on:
+  workflow_dispatch:
+    inputs:
+      semver:
+        description: 'Release bump type'
+        required: true
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+
+permissions: {}
+
+jobs:
+  release:
+    permissions:
+      id-token: write # required for npm provenance via OIDC
+      contents: write # required to push the release commit and the tag
+    uses: fastify/workflows/.github/workflows/reusable-release.yml@b1a11bce713bc857e52b2231fec3c89071ad3135
+    with:
+      semver: ${{ inputs.semver }}

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

@@ -1,12 +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).
+[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
@@ -29,11 +29,11 @@ npm i @fastify/caching
 ### Compatibility
 | Plugin version | Fastify version |
 | ---------------|-----------------|
-| `^9.x`         | `^5.x`          |
+| `>=9.x`        | `^5.x`          |
 | `^8.x`         | `^4.x`          |
-| `^6.x`         | `^3.x`          |
-| `^4.x`         | `^2.x`          |
-| `^1.x`         | `^1.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
@@ -161,7 +161,7 @@ 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
 [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
 

package/index.js

@@ -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.3",
+  "version": "9.0.5",
   "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",
@@ -63,24 +59,19 @@
     }
   ],
   "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.12.0",
-    "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/headers.test.js

@@ -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)
 

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 () => {
-  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' }
-})