@fastify/static 6.1.0 → 6.4.0

package/README.md

@@ -190,7 +190,9 @@ If set, it provide the directory list calling the directory path.
 
 Default response is json.
 
-Note: Multi-root is not supported within the `list` option.
+Note:
+- Multi-root is not supported within the `list` option.
+- If `dotfiles` option value is `deny` or `ignore`, dotfiles will be excluded.
 
 **Example:**
 

package/index.d.ts

@@ -43,13 +43,22 @@ interface ListRender {
 }
 
 interface ListOptions {
-  format: 'json' | 'html';
-  names: string[];
-  render: ListRender;
+  names?: string[];
   extendedFolderInfo?: boolean;
   jsonFormat?: 'names' | 'extended';
 }
 
+interface ListOptionsJsonFormat extends ListOptions {
+  format: 'json';
+  // Required when the URL parameter `format=html` exists
+  render?: ListRender;
+}
+
+interface ListOptionsHtmlFormat extends ListOptions {
+  format: 'html';
+  render: ListRender;
+}
+
 // Passed on to `send`
 interface SendOptions {
   acceptRanges?: boolean;
@@ -73,7 +82,7 @@ export interface FastifyStaticOptions extends SendOptions {
   setHeaders?: (...args: any[]) => void;
   redirect?: boolean;
   wildcard?: boolean;
-  list?: boolean | ListOptions;
+  list?: boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat;
   allowedPath?: (pathName: string, root?: string) => boolean;
   /**
    * @description

package/index.js

@@ -161,7 +161,8 @@ async function fastifyStatic (fastify, opts) {
           dir: path,
           options: opts.list,
           route: pathname,
-          prefix
+          prefix,
+          dotfiles: opts.dotfiles
         }).catch((err) => reply.send(err))
         return
       }
@@ -194,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) {
@@ -217,7 +218,8 @@ async function fastifyStatic (fastify, opts) {
             dir: dirList.path(opts.root, pathname),
             options: opts.list,
             route: pathname,
-            prefix
+            prefix,
+            dotfiles: opts.dotfiles
           }).catch((err) => reply.send(err))
           return
         }
@@ -492,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

@@ -8,12 +8,16 @@ const dirList = {
   /**
    * get files and dirs from dir, or error
    * @param {string} dir full path fs dir
-   * @param {function(error, entries)} callback
+   * @param {(boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat)} options
+   * @param {string} dotfiles
    * note: can't use glob because don't get error on non existing dir
    */
-  list: async function (dir, options) {
+  list: async function (dir, options, dotfiles) {
     const entries = { dirs: [], files: [] }
-    const files = await fs.readdir(dir)
+    let files = await fs.readdir(dir)
+    if (dotfiles === 'deny' || dotfiles === 'ignore') {
+      files = files.filter(f => f.charAt(0) !== '.')
+    }
     if (files.length < 1) {
       return entries
     }
@@ -95,13 +99,18 @@ const dirList = {
    * send dir list content, or 404 on error
    * @param {Fastify.Reply} reply
    * @param {string} dir full path fs dir
-   * @param {ListOptions} options
+   * @param {(boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat)} options
    * @param {string} route request route
+   * @param {string} dotfiles
    */
-  send: async function ({ reply, dir, options, route, prefix }) {
+  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)
+      entries = await dirList.list(dir, options, dotfiles)
     } catch (error) {
       return reply.callNotFound()
     }
@@ -146,7 +155,7 @@ const dirList = {
   /**
    * say if the route can be handled by dir list or not
    * @param {string} route request route
-   * @param {ListOptions} options
+   * @param {(boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat)} options
    * @return {boolean}
    */
   handle: function (route, options) {
@@ -189,6 +198,9 @@ const dirList = {
     if (options.list.names && !Array.isArray(options.list.names)) {
       return new TypeError('The `list.names` option must be an array')
     }
+    if (options.list.jsonFormat != null && options.list.jsonFormat !== 'names' && options.list.jsonFormat !== 'extended') {
+      return new TypeError('The `list.jsonFormat` option must be name or extended')
+    }
     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')
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/static",
-  "version": "6.1.0",
+  "version": "6.4.0",
   "description": "Plugin for serving static files as fast as possible.",
   "main": "index.js",
   "types": "index.d.ts",

package/test/dir-list.test.js

@@ -40,7 +40,7 @@ t.test('throws when `root` is an array', t => {
   t.equal(err.message, 'multi-root with list option is not supported')
 })
 
-t.test('throws when `list.format option` is invalid', t => {
+t.test('throws when `list.format` option is invalid', t => {
   t.plan(2)
 
   const err = dirList.validateOptions({ list: { format: 'hello' } })
@@ -56,6 +56,14 @@ t.test('throws when `list.names option` is not an array', t => {
   t.equal(err.message, 'The `list.names` option must be an array')
 })
 
+t.test('throws when `list.jsonFormat` option is invalid', t => {
+  t.plan(2)
+
+  const err = dirList.validateOptions({ list: { jsonFormat: 'hello' } })
+  t.type(err, TypeError)
+  t.equal(err.message, 'The `list.jsonFormat` option must be name or extended')
+})
+
 t.test('throws when `list.format` is html and `list render` is not a function', t => {
   t.plan(2)
 
@@ -469,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 = {
@@ -484,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({
@@ -512,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'))
     })
   })
@@ -636,6 +741,90 @@ t.test('serve a non existent dir and get error', t => {
   })
 })
 
+t.test('dir list with dotfiles allow option', t => {
+  t.plan(2)
+
+  const options = {
+    root: path.join(__dirname, '/static-dotfiles'),
+    prefix: '/public',
+    dotfiles: 'allow',
+    index: false,
+    list: true
+  }
+  const route = '/public/'
+  const content = { dirs: ['dir'], files: ['.aaa', 'test.txt'] }
+
+  helper.arrange(t, options, (url) => {
+    t.test(route, t => {
+      t.plan(3)
+      simple.concat({
+        method: 'GET',
+        url: url + route
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.equal(body.toString(), JSON.stringify(content))
+      })
+    })
+  })
+})
+
+t.test('dir list with dotfiles deny option', t => {
+  t.plan(2)
+
+  const options = {
+    root: path.join(__dirname, '/static-dotfiles'),
+    prefix: '/public',
+    dotfiles: 'deny',
+    index: false,
+    list: true
+  }
+  const route = '/public/'
+  const content = { dirs: ['dir'], files: ['test.txt'] }
+
+  helper.arrange(t, options, (url) => {
+    t.test(route, t => {
+      t.plan(3)
+      simple.concat({
+        method: 'GET',
+        url: url + route
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.equal(body.toString(), JSON.stringify(content))
+      })
+    })
+  })
+})
+
+t.test('dir list with dotfiles ignore option', t => {
+  t.plan(2)
+
+  const options = {
+    root: path.join(__dirname, '/static-dotfiles'),
+    prefix: '/public',
+    dotfiles: 'ignore',
+    index: false,
+    list: true
+  }
+  const route = '/public/'
+  const content = { dirs: ['dir'], files: ['test.txt'] }
+
+  helper.arrange(t, options, (url) => {
+    t.test(route, t => {
+      t.plan(3)
+      simple.concat({
+        method: 'GET',
+        url: url + route
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.equal(body.toString(), JSON.stringify(content))
+      })
+    })
+  })
+})
+
 t.test('dir list error', t => {
   t.plan(7)
 

package/test/static.test.js

@@ -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,5 +1,5 @@
 import fastify from 'fastify'
-import { expectError } from 'tsd'
+import { expectAssignable, expectError } from 'tsd'
 import fastifyStatic, { FastifyStaticOptions } from '../..'
 
 const appWithImplicitHttp = fastify()
@@ -32,6 +32,36 @@ expectError<FastifyStaticOptions>({
   wildcard: '**/**'
 })
 
+expectAssignable<FastifyStaticOptions>({
+  root: '',
+  list: {
+    format: 'json',
+  }
+})
+
+expectAssignable<FastifyStaticOptions>({
+  root: '',
+  list: {
+    format: 'json',
+    render: () => ''
+  }
+})
+
+expectAssignable<FastifyStaticOptions>({
+  root: '',
+  list: {
+    format: 'html',
+    render: () => ''
+  }
+})
+
+expectError<FastifyStaticOptions>({
+  root: '',
+  list: {
+    format: 'html',
+  }
+})
+
 appWithImplicitHttp
   .register(fastifyStatic, options)
   .after(() => {