@fastify/caching 9.0.1 → 9.0.2

package/.github/workflows/ci.yml

@@ -17,7 +17,7 @@ on:
 
 jobs:
   test:
-    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5.0.0
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
     with:
       license-check: true
       lint: true

package/Readme.md

@@ -1,8 +1,8 @@
 # @fastify/caching
 
-![CI](https://github.com/fastify/fastify-caching/workflows/CI/badge.svg)
+[![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)
 [![NPM version](https://img.shields.io/npm/v/@fastify/caching.svg?style=flat)](https://www.npmjs.com/package/@fastify/caching)
-[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
+[![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
 that provides server-side caching and mechanisms for manipulating HTTP cache headers according to
@@ -105,14 +105,14 @@ fastify.listen({ port: 3000 }, (err) => {
 for a *cache-response-directive* as defined by RFC 2616.
 + `expiresIn` (Default: `undefined`): a value, in seconds, for the *max-age* the
 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. 
+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
 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
 communicating with the cache.
-+ `serverExpiresIn` (Default: `undefined`): a value, in seconds, for the length of time the resource is fresh and may be held in a shared cache (e.g. a CDN). Shared caches will ignore max-age when this is specified, though browsers will continue to use max-age. Should be used with expiresIn, not in place of it. When this is set, and `privacy` is set to `public`,  then `', s-maxage=<value>'` will be appended to the `cache-control` header.  
++ `serverExpiresIn` (Default: `undefined`): a value, in seconds, for the length of time the resource is fresh and may be held in a shared cache (e.g. a CDN). Shared caches will ignore max-age when this is specified, though browsers will continue to use max-age. Should be used with expiresIn, not in place of it. When this is set, and `privacy` is set to `public`,  then `', s-maxage=<value>'` will be appended to the `cache-control` header.
 
 [acache]: https://www.npmjs.com/package/abstract-cache
 

package/eslint.config.js

@@ -0,0 +1,6 @@
+'use strict'
+
+module.exports = require('neostandard')({
+  ignores: require('neostandard').resolveIgnoresFromGitignore(),
+  ts: true
+})

package/index.js

@@ -26,7 +26,7 @@ function etag (value, lifetime) {
   return this
 }
 
-function etagHandleRequest (req, res, next) {
+function cachingLoadByEtag (req, res, next) {
   if (!req.headers['if-none-match']) return next()
   const etag = req.headers['if-none-match']
   this.cache.get({ id: etag, segment: this.cacheSegment }, (err, cached) => {
@@ -38,7 +38,7 @@ function etagHandleRequest (req, res, next) {
   })
 }
 
-function etagOnSend (req, res, payload, next) {
+function cachingStoreByEtag (req, res, payload, next) {
   const etag = res.getHeader('etag')
   if (!etag || !res._etagLife) return next()
   this.cache.set(
@@ -70,7 +70,7 @@ function fastifyCaching (instance, options, next) {
       value += `, s-maxage=${_options.serverExpiresIn}`
     }
 
-    instance.addHook('onRequest', (req, res, next) => {
+    instance.addHook('onRequest', function cachingSetCacheControlHeader (req, res, next) {
       if (!res.hasHeader('Cache-control')) {
         res.header('Cache-control', value)
       }
@@ -83,8 +83,8 @@ function fastifyCaching (instance, options, next) {
   instance.decorate('etagMaxLife', _options.etagMaxLife)
   instance.decorateReply('etag', etag)
   instance.decorateReply('expires', cachingExpires)
-  instance.addHook('onRequest', etagHandleRequest)
-  instance.addHook('onSend', etagOnSend)
+  instance.addHook('onRequest', cachingLoadByEtag)
+  instance.addHook('onSend', cachingStoreByEtag)
 
   instance[Symbol.for('fastify-caching.registered')] = true
   next()

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fastify/caching",
-  "version": "9.0.1",
+  "version": "9.0.2",
   "description": "A plugin for Fastify to enable management of cache control headers",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "lint": "standard --verbose | snazzy",
-    "lint:fix": "standard --verbose --fix | snazzy",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
     "test:unit": "c8 --100 node --test",
@@ -38,8 +38,7 @@
     "@types/node": "^22.0.0",
     "c8": "^10.1.2",
     "fastify": "^5.0.0",
-    "snazzy": "^9.0.0",
-    "standard": "^17.1.0",
+    "neostandard": "^0.11.9",
     "tsd": "^0.31.0"
   },
   "dependencies": {

package/test/cache.test.js

@@ -22,13 +22,13 @@ test('cache is usable', async (t) => {
 
   const fastify = Fastify()
   await fastify.register(async (instance, options) => {
-    instance.addHook('onRequest', async function (req, reply) {
+    instance.addHook('onRequest', async function checkCachingRegistered (req, reply) {
       t.assert.ifError(instance[Symbol.for('fastify-caching.registered')])
     })
   })
   await fastify.register(plugin)
 
-  fastify.addHook('onRequest', async function (req, reply) {
+  fastify.addHook('onRequest', async function checkCachingRegistered (req, reply) {
     t.assert.strictEqual(this[Symbol.for('fastify-caching.registered')], true)
   })
 
@@ -71,13 +71,13 @@ test('cache is usable with function as plugin default options input', async (t)
 
   const fastify = Fastify()
   await fastify.register(async (instance, options) => {
-    instance.addHook('onRequest', async function (req, reply) {
+    instance.addHook('onRequest', async function checkCachingNotRegistered (req, reply) {
       t.assert.failure(instance[Symbol.for('fastify-caching.registered')])
     })
   })
   await fastify.register(plugin, () => () => {})
 
-  fastify.addHook('onRequest', async function (req, reply) {
+  fastify.addHook('onRequest', async function checkCachingRegistered (req, reply) {
     t.assert.strictEqual(this[Symbol.for('fastify-caching.registered')], true)
   })
 

package/test/headers.test.js

@@ -151,7 +151,7 @@ test('do not set headers if another upstream plugin already sets it', async (t)
   }
 
   const fastify = Fastify()
-  fastify.addHook('onRequest', async (req, reply) => {
+  fastify.addHook('onRequest', async function checkCachingDoesNotOverrideCacheControlHeader (req, reply) {
     reply.header('cache-control', 'do not override')
   })
   await fastify.register(plugin, opts)

package/types/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types='node' />
 
-import { FastifyPluginCallback } from 'fastify';
+import { FastifyPluginCallback } from 'fastify'
 
 declare module 'fastify' {
   interface FastifyInstance {
@@ -33,13 +33,13 @@ declare module 'fastify' {
 
 type FastifyCaching = FastifyPluginCallback<fastifyCaching.FastifyCachingPluginOptions> & {
   privacy: fastifyCaching.Privacy;
-};
+}
 
 type CacheResult<T> = {
   item: T,
   stored: number,
   ttl: number,
-} | null;
+} | null
 
 declare namespace fastifyCaching {
   /**
@@ -130,11 +130,11 @@ declare namespace fastifyCaching {
     serverExpiresIn?: number;
   }
 
-  export const privacy: Privacy;
+  export const privacy: Privacy
 
-  export const fastifyCaching: FastifyCaching;
-  export { fastifyCaching as default };
+  export const fastifyCaching: FastifyCaching
+  export { fastifyCaching as default }
 }
 
-declare function fastifyCaching(...params: Parameters<FastifyCaching>): ReturnType<FastifyCaching>
+declare function fastifyCaching (...params: Parameters<FastifyCaching>): ReturnType<FastifyCaching>
 export = fastifyCaching

package/types/index.test-d.ts

@@ -1,69 +1,69 @@
-import Fastify, { FastifyReply } from 'fastify';
-import { expectAssignable, expectError, expectType } from 'tsd';
+import Fastify, { FastifyReply } from 'fastify'
+import { expectAssignable, expectError, expectType } from 'tsd'
 import fastifyCaching, {
   AbstractCacheCompliantObject,
   FastifyCachingPluginOptions,
-} from '..';
+} from '..'
 
-const fastify = Fastify({ logger: true });
+const fastify = Fastify({ logger: true })
 
 const cachingOptions: FastifyCachingPluginOptions = {
   privacy: fastifyCaching.privacy.PUBLIC,
   expiresIn: 300,
   cacheSegment: 'fastify-caching',
-};
-expectAssignable<FastifyCachingPluginOptions>(cachingOptions);
+}
+expectAssignable<FastifyCachingPluginOptions>(cachingOptions)
 
-fastify.register(fastifyCaching, 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<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<(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)));
+  expectType<FastifyReply>(reply.etag('hello', 6000))
+  expectType<FastifyReply>(reply.expires(new Date(Date.now() + 6000)))
 
-  return { message: 'one' };
-});
+  return { message: 'one' }
+})
 
 fastify.get('/two', async (request, reply) => {
   expectType<FastifyReply>(
     reply.etag('hello', 6000).expires(new Date(Date.now() + 6000))
-  );
+  )
 
-  return { message: 'two' };
-});
+  return { message: 'two' }
+})
 
 // We register a new instance that should trigger a typescript error.
-const shouldErrorApp = Fastify({ logger: true });
+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));
+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);
+      expectType<unknown>(err)
+      expectAssignable<{ item: string; stored: number; ttl: number; } | null>(value)
     })
-  );
+  )
 
-  return { message: 'two' };
-});
+  return { message: 'two' }
+})