Nodenext compatibility (#116)

Author: Uzlopak

plugin.js renamed to index.js

@@ -53,7 +53,7 @@ function etagOnSend (req, res, payload, next) {
   )
 }
 
-function fastifyCachingPlugin (instance, options, next) {
+function fastifyCaching (instance, options, next) {
   let _options
   if (Function.prototype.isPrototypeOf(options)) {
     _options = Object.assign({}, defaultOptions)
@@ -92,10 +92,12 @@ function fastifyCachingPlugin (instance, options, next) {
   next()
 }
 
-module.exports = fp(fastifyCachingPlugin, {
+module.exports = fp(fastifyCaching, {
   fastify: '4.x',
   name: '@fastify/caching'
 })
+module.exports.default = fastifyCaching
+module.exports.fastifyCaching = fastifyCaching
 
 module.exports.privacy = {
   NOCACHE: 'no-cache',

package.json

@@ -2,8 +2,8 @@
   "name": "@fastify/caching",
   "version": "8.0.1",
   "description": "A plugin for Fastify to enable management of cache control headers",
-  "main": "plugin.js",
-  "types": "plugin.d.ts",
+  "main": "index.js",
+  "types": "types/index.d.ts",
   "scripts": {
     "lint": "standard --verbose | snazzy",
     "test": "npm run test:unit && npm run test:typescript",
@@ -45,9 +45,6 @@
     "fastify-plugin": "^4.0.0",
     "uid-safe": "^2.1.5"
   },
-  "tsd": {
-    "directory": "test/types"
-  },
   "publishConfig": {
     "access": "public"
   },

plugin.d.ts

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('tap')
-const plugin = require('../plugin')
+const plugin = require('..')
 
 const Fastify = require('fastify')
 

test/cache.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('tap')
 const Fastify = require('fastify')
-const plugin = require('../plugin')
+const plugin = require('..')
 
 test('decorators get added', async (t) => {
   t.plan(1)

test/headers.test.js

@@ -0,0 +1,128 @@
+/// <reference types='node' />
+
+import { FastifyPluginCallback } from 'fastify';
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    cache: fastifyCaching.AbstractCacheCompliantObject;
+    cacheSegment: string;
+    etagMaxLife: number | undefined;
+  }
+
+  interface FastifyReply {
+    /**
+     * This method allows setting of the `expires` header.
+     *
+     * @link [reply.expires() documentation](https://github.com/fastify/fastify-caching#replyexpiresdate)
+     *
+     * @param date A regular `Date` object, or a valid date string according to [RFC 2616 section 14.21](https://datatracker.ietf.org/doc/html/rfc2616#section-14.21).
+     */
+    expires(date?: Date): this;
+
+    /**
+     * This method allows setting of the `etag` header.
+     *
+     * @link [reply.etag() documentation](https://github.com/fastify/fastify-caching#replyetagstring-number)
+     *
+     * @param tag Any arbitrary string that is valid for HTTP headers.
+     * @param timeToLive The time must be specified in milliseconds. The default lifetime, when the parameter is not specified, is `3600000`.
+     */
+    etag(tag?: string, timeToLive?: number): this;
+  }
+}
+
+type FastifyCaching = FastifyPluginCallback<fastifyCaching.FastifyCachingPluginOptions> & {
+  privacy: fastifyCaching.Privacy;
+};
+
+declare namespace fastifyCaching {
+  /**
+   * @link [`abstract-cache` protocol documentation](https://github.com/jsumners/abstract-cache#protocol)
+   */
+  export interface AbstractCacheCompliantObject {
+    get(
+      key: string | { id: string; segment: string },
+      callback?: (error: unknown, result: unknown) => void
+    ): void;
+    set(
+      key: string | { id: string; segment: string },
+      value: unknown,
+      timeToLive: number,
+      callback?: (error: unknown, result: unknown) => void
+    ): void;
+  }
+
+  export interface Privacy {
+    NOCACHE: 'no-cache';
+    PRIVATE: 'private';
+    PUBLIC: 'public';
+  }
+
+  /**
+   * @link [`fastify-caching` options documentation](https://github.com/fastify/fastify-caching#options)
+   */
+  export interface FastifyCachingPluginOptions {
+    /**
+     * An [abstract-cache](https://www.npmjs.com/package/abstract-cache) 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.
+     *
+     * - Default value: `abstract-cache.memclient`
+     */
+    cache?: AbstractCacheCompliantObject;
+
+    /**
+     * The segment identifier to use when communicating with the cache.
+     *
+     * - Default value: `fastify-caching`
+     */
+    cacheSegment?: string;
+
+    etagMaxLife?: number;
+
+    /**
+     * 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.
+     *
+     * - Default value: `undefined`
+     */
+    expiresIn?: number;
+
+    /**
+     * It can be set to any string that is valid for a cache-response-directive as
+     * defined by [RFC 2616](https://datatracker.ietf.org/doc/html/rfc2616#section-14.9).
+     *
+     * - Default value: `undefined`
+     *
+     * @link [MDN Cache-Control - Response Directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#response_directives)
+     *
+     * @example
+     * const fastifyCaching = require('fastify-caching');
+     *
+     * // Disabling client side caching of all routes.
+     * fastify.register(fastifyCaching, { privacy: fastifyCaching.privacy.NOCACHE });
+     */
+    privacy?: string;
+
+    /**
+     * 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.
+     *
+     * - Default value: `undefined`
+     */
+    serverExpiresIn?: number;
+  }
+
+  export const privacy: {
+    privacy: Privacy;
+  };
+  export const fastifyCaching: FastifyCaching;
+  export { fastifyCaching as default };
+}
+
+declare function fastifyCaching(...params: Parameters<FastifyCaching>): ReturnType<FastifyCaching>
+export = fastifyCaching

types/index.d.ts

@@ -3,7 +3,7 @@ import { expectAssignable, expectError, expectType } from 'tsd';
 import fastifyCaching, {
   AbstractCacheCompliantObject,
   FastifyCachingPluginOptions,
-} from '../..';
+} from '..';
 
 const fastify = Fastify({ logger: true });