@fastify/static 6.3.0 → 6.3.1

package/index.d.ts

@@ -8,98 +8,108 @@ import { Stats } from 'fs';
 declare module "fastify" {
   interface FastifyReply {
     sendFile(filename: string, rootPath?: string): FastifyReply;
-    sendFile(filename: string, options?: SendOptions): FastifyReply;
-    sendFile(filename: string, rootPath?: string, options?: SendOptions): FastifyReply;
-    download(filepath: string, options?: SendOptions): FastifyReply;
+    sendFile(filename: string, options?: fastifyStatic.SendOptions): FastifyReply;
+    sendFile(filename: string, rootPath?: string, options?: fastifyStatic.SendOptions): FastifyReply;
+    download(filepath: string, options?: fastifyStatic.SendOptions): FastifyReply;
     download(filepath: string, filename?: string): FastifyReply;
-    download(filepath: string, filename?: string, options?: SendOptions): FastifyReply;
+    download(filepath: string, filename?: string, options?: fastifyStatic.SendOptions): FastifyReply;
   }
 }
 
-interface ExtendedInformation {
-  fileCount: number;
-  totalFileCount: number;
-  folderCount: number;
-  totalFolderCount: number;
-  totalSize: number;
-  lastModified: number;
-}
-
-interface ListDir {
-  href: string;
-  name: string;
-  stats: Stats;
-  extendedInfo?: ExtendedInformation;
-}
+type FastifyStaticPlugin = FastifyPluginCallback<NonNullable<fastifyStatic.FastifyStaticOptions>>;
 
-interface ListFile {
-  href: string;
-  name: string;
-  stats: Stats;
-}
+declare namespace fastifyStatic {
+  export interface ExtendedInformation {
+    fileCount: number;
+    totalFileCount: number;
+    folderCount: number;
+    totalFolderCount: number;
+    totalSize: number;
+    lastModified: number;
+  }
 
-interface ListRender {
-  (dirs: ListDir[], files: ListFile[]): string;
-}
+  export interface ListDir {
+    href: string;
+    name: string;
+    stats: Stats;
+    extendedInfo?: ExtendedInformation;
+  }
 
-interface ListOptions {
-  names?: string[];
-  extendedFolderInfo?: boolean;
-}
+  export interface ListFile {
+    href: string;
+    name: string;
+    stats: Stats;
+  }
 
-interface ListOptionsJsonFormat extends ListOptions {
-  format: 'json';
-  jsonFormat?: 'names' | 'extended';
-}
+  export interface ListRender {
+    (dirs: ListDir[], files: ListFile[]): string;
+  }
 
-interface ListOptionsHtmlFormat extends ListOptions {
-  format: 'html';
-  render: ListRender;
-}
+  export interface ListOptions {
+    names?: string[];
+    extendedFolderInfo?: boolean;
+    jsonFormat?: 'names' | 'extended';
+  }
 
-// Passed on to `send`
-interface SendOptions {
-  acceptRanges?: boolean;
-  cacheControl?: boolean;
-  dotfiles?: 'allow' | 'deny' | 'ignore';
-  etag?: boolean;
-  extensions?: string[];
-  immutable?: boolean;
-  index?: string[] | string | false;
-  lastModified?: boolean;
-  maxAge?: string | number;
-}
+  export interface ListOptionsJsonFormat extends ListOptions {
+    format: 'json';
+    // Required when the URL parameter `format=html` exists
+    render?: ListRender;
+  }
 
-export interface FastifyStaticOptions extends SendOptions {
-  root: string | string[];
-  prefix?: string;
-  prefixAvoidTrailingSlash?: boolean;
-  serve?: boolean;
-  decorateReply?: boolean;
-  schemaHide?: boolean;
-  setHeaders?: (...args: any[]) => void;
-  redirect?: boolean;
-  wildcard?: boolean;
-  list?: boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat;
-  allowedPath?: (pathName: string, root?: string) => boolean;
-  /**
-   * @description
-   * Opt-in to looking for pre-compressed files
-   */
-  preCompressed?: boolean;
+  export interface ListOptionsHtmlFormat extends ListOptions {
+    format: 'html';
+    render: ListRender;
+  }
 
   // Passed on to `send`
-  acceptRanges?: boolean;
-  cacheControl?: boolean;
-  dotfiles?: 'allow' | 'deny' | 'ignore';
-  etag?: boolean;
-  extensions?: string[];
-  immutable?: boolean;
-  index?: string[] | string | false;
-  lastModified?: boolean;
-  maxAge?: string | number;
+  export interface SendOptions {
+    acceptRanges?: boolean;
+    cacheControl?: boolean;
+    dotfiles?: 'allow' | 'deny' | 'ignore';
+    etag?: boolean;
+    extensions?: string[];
+    immutable?: boolean;
+    index?: string[] | string | false;
+    lastModified?: boolean;
+    maxAge?: string | number;
+  }
+
+  export interface FastifyStaticOptions extends SendOptions {
+    root: string | string[];
+    prefix?: string;
+    prefixAvoidTrailingSlash?: boolean;
+    serve?: boolean;
+    decorateReply?: boolean;
+    schemaHide?: boolean;
+    setHeaders?: (...args: any[]) => void;
+    redirect?: boolean;
+    wildcard?: boolean;
+    list?: boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat;
+    allowedPath?: (pathName: string, root?: string) => boolean;
+    /**
+     * @description
+     * Opt-in to looking for pre-compressed files
+     */
+    preCompressed?: boolean;
+
+    // Passed on to `send`
+    acceptRanges?: boolean;
+    cacheControl?: boolean;
+    dotfiles?: 'allow' | 'deny' | 'ignore';
+    etag?: boolean;
+    extensions?: string[];
+    immutable?: boolean;
+    index?: string[] | string | false;
+    lastModified?: boolean;
+    maxAge?: string | number;
+  }
+
+  export const fastifyStatic: FastifyStaticPlugin;
+
+  export { fastifyStatic as default };
 }
 
-export declare const fastifyStatic: FastifyPluginCallback<FastifyStaticOptions>
+declare function fastifyStatic(...params: Parameters<FastifyStaticPlugin>): ReturnType<FastifyStaticPlugin>;
 
-export default fastifyStatic;
+export = fastifyStatic;

package/index.js

@@ -9,7 +9,7 @@ const contentDisposition = require('content-disposition')
 const fp = require('fastify-plugin')
 const util = require('util')
 const globPromise = util.promisify(glob)
-const encodingNegotiator = require('encoding-negotiator')
+const encodingNegotiator = require('@fastify/accept-negotiator')
 
 const dirList = require('./lib/dirList')
 
@@ -195,7 +195,7 @@ async function fastifyStatic (fastify, opts) {
 
     stream.on('error', function (err) {
       if (err.code === 'ENOENT') {
-        // when preCompress is enabled and the path is a directoy without a trailing shash
+        // when preCompress is enabled and the path is a directory without a trailing slash
         if (opts.preCompressed && encoding) {
           const indexPathname = findIndexFile(pathname, options.root, options.index)
           if (indexPathname) {
@@ -494,7 +494,7 @@ function getEncodingExtension (encoding) {
 
 function getRedirectUrl (url) {
   let i = 0
-  // we detech how many slash before a valid path
+  // we detect how many slash before a valid path
   for (i; i < url.length; i++) {
     if (url[i] !== '/' && url[i] !== '\\') break
   }

package/lib/dirList.js

@@ -104,6 +104,10 @@ const dirList = {
    * @param {string} dotfiles
    */
   send: async function ({ reply, dir, options, route, prefix, dotfiles }) {
+    if (reply.request.query.format === 'html' && typeof options.render !== 'function') {
+      throw new Error('The `list.render` option must be a function and is required with the URL parameter `format=html`')
+    }
+
     let entries
     try {
       entries = await dirList.list(dir, options, dotfiles)
@@ -200,9 +204,6 @@ const dirList = {
     if (options.list.format === 'html' && typeof options.list.render !== 'function') {
       return new TypeError('The `list.render` option must be a function and is required with html format')
     }
-    if (options.list.format === 'html' && options.list.jsonFormat != null) {
-      return new TypeError('The `list.jsonFormat` option must be with json format')
-    }
   }
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/static",
-  "version": "6.3.0",
+  "version": "6.3.1",
   "description": "Plugin for serving static files as fast as possible.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,16 +30,16 @@
   "homepage": "https://github.com/fastify/fastify-static",
   "dependencies": {
     "content-disposition": "^0.5.3",
-    "encoding-negotiator": "^2.0.1",
-    "fastify-plugin": "^3.0.0",
+    "@fastify/accept-negotiator": "^1.0.0",
+    "fastify-plugin": "^4.0.0",
     "glob": "^8.0.1",
     "p-limit": "^3.1.0",
-    "readable-stream": "^3.4.0",
+    "readable-stream": "^4.0.0",
     "send": "^0.18.0"
   },
   "devDependencies": {
     "@fastify/compress": "^6.0.0",
-    "@types/node": "^17.0.0",
+    "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^2.29.0",
     "@typescript-eslint/parser": "^2.29.0",
     "concat-stream": "^2.0.0",
@@ -53,7 +53,7 @@
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "tsd": "^0.20.0",
+    "tsd": "^0.22.0",
     "typescript": "^4.0.2"
   },
   "tsd": {

package/test/dir-list.test.js

@@ -72,14 +72,6 @@ t.test('throws when `list.format` is html and `list render` is not a function',
   t.equal(err.message, 'The `list.render` option must be a function and is required with html format')
 })
 
-t.test('throws when `list.format` is html and `list.jsonFormat` is given', t => {
-  t.plan(2)
-
-  const err = dirList.validateOptions({ list: { format: 'html', render: () => '', jsonFormat: 'extended' } })
-  t.type(err, TypeError)
-  t.equal(err.message, 'The `list.jsonFormat` option must be with json format')
-})
-
 t.test('dir list wrong options', t => {
   t.plan(3)
 
@@ -485,7 +477,103 @@ t.test('dir list json format - extended info', t => {
   })
 })
 
-t.test('dir list - url parameter format', t => {
+t.test('json format with url parameter format', t => {
+  t.plan(13)
+
+  const options = {
+    root: path.join(__dirname, '/static'),
+    prefix: '/public',
+    index: false,
+    list: {
+      format: 'json',
+      render (dirs, files) {
+        return 'html'
+      }
+    }
+  }
+  const route = '/public/'
+  const jsonContent = { dirs: ['deep', 'shallow'], files: ['.example', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
+
+  helper.arrange(t, options, (url) => {
+    simple.concat({
+      method: 'GET',
+      url: url + route
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.ok(response.headers['content-type'].includes('application/json'))
+    })
+
+    simple.concat({
+      method: 'GET',
+      url: url + route + '?format=html'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), 'html')
+      t.ok(response.headers['content-type'].includes('text/html'))
+    })
+
+    simple.concat({
+      method: 'GET',
+      url: url + route + '?format=json'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.ok(response.headers['content-type'].includes('application/json'))
+    })
+  })
+})
+
+t.test('json format with url parameter format and without render option', t => {
+  t.plan(12)
+
+  const options = {
+    root: path.join(__dirname, '/static'),
+    prefix: '/public',
+    index: false,
+    list: {
+      format: 'json'
+    }
+  }
+  const route = '/public/'
+  const jsonContent = { dirs: ['deep', 'shallow'], files: ['.example', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
+
+  helper.arrange(t, options, (url) => {
+    simple.concat({
+      method: 'GET',
+      url: url + route
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.ok(response.headers['content-type'].includes('application/json'))
+    })
+
+    simple.concat({
+      method: 'GET',
+      url: url + route + '?format=html'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 500)
+      t.equal(JSON.parse(body.toString()).message, 'The `list.render` option must be a function and is required with the URL parameter `format=html`')
+    })
+
+    simple.concat({
+      method: 'GET',
+      url: url + route + '?format=json'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.toString(), JSON.stringify(jsonContent))
+      t.ok(response.headers['content-type'].includes('application/json'))
+    })
+  })
+})
+
+t.test('html format with url parameter format', t => {
   t.plan(13)
 
   const options = {
@@ -500,6 +588,7 @@ t.test('dir list - url parameter format', t => {
     }
   }
   const route = '/public/'
+  const jsonContent = { dirs: ['deep', 'shallow'], files: ['.example', 'a .md', 'foo.html', 'foobar.html', 'index.css', 'index.html'] }
 
   helper.arrange(t, options, (url) => {
     simple.concat({
@@ -528,7 +617,7 @@ t.test('dir list - url parameter format', t => {
     }, (err, response, body) => {
       t.error(err)
       t.equal(response.statusCode, 200)
-      t.ok(body.toString())
+      t.equal(body.toString(), JSON.stringify(jsonContent))
       t.ok(response.headers['content-type'].includes('application/json'))
     })
   })

package/test/static.test.js

@@ -1642,7 +1642,7 @@ t.test('with fastify-compress', t => {
   })
 })
 t.test('register /static/ with schemaHide true', t => {
-  t.plan(5)
+  t.plan(4)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1682,7 +1682,7 @@ t.test('register /static/ with schemaHide true', t => {
 })
 
 t.test('register /static/ with schemaHide false', t => {
-  t.plan(5)
+  t.plan(4)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -1722,7 +1722,7 @@ t.test('register /static/ with schemaHide false', t => {
 })
 
 t.test('register /static/ without schemaHide', t => {
-  t.plan(5)
+  t.plan(4)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -2769,7 +2769,7 @@ t.test('inject support', async (t) => {
 })
 
 t.test('routes should use custom errorHandler premature stream close', t => {
-  t.plan(5)
+  t.plan(4)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -2804,7 +2804,7 @@ t.test('routes should use custom errorHandler premature stream close', t => {
 })
 
 t.test('routes should fallback to default errorHandler', t => {
-  t.plan(5)
+  t.plan(4)
 
   const pluginOptions = {
     root: path.join(__dirname, '/static'),
@@ -2840,7 +2840,7 @@ t.test('routes should fallback to default errorHandler', t => {
   })
 })
 
-t.test('precent encoded URLs in glob mode', (t) => {
+t.test('percent encoded URLs in glob mode', (t) => {
   t.plan(4)
 
   const fastify = Fastify({})

package/test/types/index.ts

@@ -1,6 +1,34 @@
-import fastify from 'fastify'
-import { expectAssignable, expectError } from 'tsd'
-import fastifyStatic, { FastifyStaticOptions } from '../..'
+import fastify, { FastifyInstance, FastifyPluginCallback } from 'fastify'
+import { Server } from 'http';
+import { expectAssignable, expectError, expectType } from 'tsd'
+import * as fastifyStaticStar from '../..';
+import fastifyStatic, {
+  FastifyStaticOptions, 
+  fastifyStatic as fastifyStaticNamed,
+} from '../..'
+
+import fastifyStaticCjsImport = require('../..');
+const fastifyStaticCjs = require('../..');
+
+const app: FastifyInstance = fastify();
+
+app.register(fastifyStatic);
+app.register(fastifyStaticNamed);
+app.register(fastifyStaticCjs);
+app.register(fastifyStaticCjsImport.default);
+app.register(fastifyStaticCjsImport.fastifyStatic);
+app.register(fastifyStaticStar.default);
+app.register(fastifyStaticStar.fastifyStatic);
+
+expectType<FastifyPluginCallback<FastifyStaticOptions, Server>>(fastifyStatic);
+expectType<FastifyPluginCallback<FastifyStaticOptions, Server>>(fastifyStaticNamed);
+expectType<FastifyPluginCallback<FastifyStaticOptions, Server>>(fastifyStaticCjsImport.default);
+expectType<FastifyPluginCallback<FastifyStaticOptions, Server>>(fastifyStaticCjsImport.fastifyStatic);
+expectType<FastifyPluginCallback<FastifyStaticOptions, Server>>(fastifyStaticStar.default);
+expectType<FastifyPluginCallback<FastifyStaticOptions, Server>>(
+fastifyStaticStar.fastifyStatic
+);
+expectType<any>(fastifyStaticCjs);
 
 const appWithImplicitHttp = fastify()
 const options: FastifyStaticOptions = {
@@ -39,7 +67,7 @@ expectAssignable<FastifyStaticOptions>({
   }
 })
 
-expectError<FastifyStaticOptions>({
+expectAssignable<FastifyStaticOptions>({
   root: '',
   list: {
     format: 'json',