@fastify/static 6.12.0 → 7.0.1

package/README.md

@@ -124,7 +124,7 @@ A URL path prefix used to create a virtual mount path for the static directory.
 Default: `{}`
 
 Constraints that will be added to registered routes. See Fastify's documentation for
-[route constraints](https://www.fastify.io/docs/latest/Reference/Routes/#constraints).
+[route constraints](https://fastify.dev/docs/latest/Reference/Routes/#constraints).
 
 #### `prefixAvoidTrailingSlash`
 
@@ -450,7 +450,7 @@ decorators.
 
 If a request matches the URL `prefix` but a file cannot be found for the
 request, Fastify's 404 handler will be called. You can set a custom 404
-handler with [`fastify.setNotFoundHandler()`](https://www.fastify.io/docs/latest/Reference/Server/#setnotfoundhandler).
+handler with [`fastify.setNotFoundHandler()`](https://fastify.dev/docs/latest/Reference/Server/#setnotfoundhandler).
 
 When registering `@fastify/static` within an encapsulated context, the `wildcard` option may need to be set to `false` in order to support index resolution and nested not-found-handler:
 
@@ -475,7 +475,7 @@ This code will send the `index.html` for the paths `docs`, `docs/`, and `docs/in
 
 If an error occurs while trying to send a file, the error will be passed
 to Fastify's error handler. You can set a custom error handler with
-[`fastify.setErrorHandler()`](https://www.fastify.io/docs/latest/Reference/Server/#seterrorhandler).
+[`fastify.setErrorHandler()`](https://fastify.dev/docs/latest/Reference/Server/#seterrorhandler).
 
 ### Payload `stream.filename`
 

package/index.js

@@ -4,9 +4,7 @@ const { PassThrough } = require('node:stream')
 const path = require('node:path')
 const { fileURLToPath } = require('node:url')
 const { statSync } = require('node:fs')
-const { promisify } = require('node:util')
-const glob = require('glob')
-const globPromise = promisify(glob)
+const { glob } = require('glob')
 const fp = require('fastify-plugin')
 const send = require('@fastify/send')
 const encodingNegotiator = require('@fastify/accept-negotiator')
@@ -14,11 +12,7 @@ const contentDisposition = require('content-disposition')
 
 const dirList = require('./lib/dirList')
 
-const winSeparatorRegex = new RegExp(`\\${path.win32.sep}`, 'gu')
-const backslashRegex = /\\/gu
-const startForwardSlashRegex = /^\//u
 const endForwardSlashRegex = /\/$/u
-const doubleForwardSlashRegex = /\/\//gu
 const asteriskRegex = /\*/gu
 
 const supportedEncodings = ['br', 'gzip', 'deflate']
@@ -117,32 +111,30 @@ async function fastifyStatic (fastify, opts) {
       throw new Error('"wildcard" option must be a boolean')
     }
     if (opts.wildcard === undefined || opts.wildcard === true) {
-      fastify.head(prefix + '*', routeOpts, function (req, reply) {
-        pumpSendToReply(req, reply, '/' + req.params['*'], sendOptions.root)
-      })
-      fastify.get(prefix + '*', routeOpts, function (req, reply) {
+      fastify.get(prefix + '*', { ...routeOpts, exposeHeadRoute: true }, (req, reply) => {
         pumpSendToReply(req, reply, '/' + req.params['*'], sendOptions.root)
       })
       if (opts.redirect === true && prefix !== opts.prefix) {
-        fastify.get(opts.prefix, routeOpts, function (req, reply) {
+        fastify.get(opts.prefix, routeOpts, (req, reply) => {
           reply.redirect(301, getRedirectUrl(req.raw.url))
         })
       }
     } else {
-      const globPattern = '**/**'
+      const indexes = opts.index === undefined ? ['index.html'] : [].concat(opts.index)
       const indexDirs = new Map()
       const routes = new Set()
 
       const roots = Array.isArray(sendOptions.root) ? sendOptions.root : [sendOptions.root]
-      for (let i = 0; i < roots.length; ++i) {
-        const rootPath = roots[i]
-        const files = await globPromise(path.join(rootPath, globPattern).replace(winSeparatorRegex, path.posix.sep), { nodir: true, dot: opts.serveDotFiles })
-        const indexes = opts.index === undefined ? ['index.html'] : [].concat(opts.index)
+      for (let rootPath of roots) {
+        rootPath = rootPath.split(path.win32.sep).join(path.posix.sep)
+        !rootPath.endsWith('/') && (rootPath += '/')
+        const files = await glob('**/**', {
+          cwd: rootPath, absolute: false, follow: true, nodir: true, dot: opts.serveDotFiles
+        })
 
-        for (let i = 0; i < files.length; ++i) {
-          const file = files[i].replace(rootPath.replace(backslashRegex, '/'), '')
-            .replace(startForwardSlashRegex, '')
-          const route = (prefix + file).replace(doubleForwardSlashRegex, '/')
+        for (let file of files) {
+          file = file.split(path.win32.sep).join(path.posix.sep)
+          const route = prefix + file
 
           if (routes.has(route)) {
             continue
@@ -150,7 +142,7 @@ async function fastifyStatic (fastify, opts) {
 
           routes.add(route)
 
-          setUpHeadAndGet(routeOpts, route, '/' + file, rootPath)
+          setUpHeadAndGet(routeOpts, route, `/${file}`, rootPath)
 
           const key = path.posix.basename(route)
           if (indexes.includes(key) && !indexDirs.has(key)) {
@@ -179,7 +171,7 @@ async function fastifyStatic (fastify, opts) {
     pathname,
     rootPath,
     rootPathOffset = 0,
-    pumpOptions = {},
+    pumpOptions,
     checkedEncodings
   ) {
     const options = Object.assign({}, sendOptions, pumpOptions)

package/lib/dirList.js

@@ -1,10 +1,60 @@
 'use strict'
 
+const os = require('node:os')
 const path = require('node:path')
 const fs = require('node:fs/promises')
-const pLimit = require('p-limit')
+const fastq = require('fastq')
+const fastqConcurrency = Math.max(1, os.cpus().length - 1)
 
 const dirList = {
+  _getExtendedInfo: async function (dir, info) {
+    const depth = dir.split(path.sep).length
+    const files = await fs.readdir(dir)
+
+    const worker = async (filename) => {
+      const filePath = path.join(dir, filename)
+      let stats
+      try {
+        stats = await fs.stat(filePath)
+      } catch {
+        return
+      }
+
+      if (stats.isDirectory()) {
+        info.totalFolderCount++
+        filePath.split(path.sep).length === depth + 1 && info.folderCount++
+        await dirList._getExtendedInfo(filePath, info)
+      } else {
+        info.totalSize += stats.size
+        info.totalFileCount++
+        filePath.split(path.sep).length === depth + 1 && info.fileCount++
+        info.lastModified = Math.max(info.lastModified, stats.mtimeMs)
+      }
+    }
+    const queue = fastq.promise(worker, fastqConcurrency)
+    await Promise.all(files.map(filename => queue.push(filename)))
+  },
+
+  /**
+   * get extended info about a folder
+   * @param {string} folderPath full path fs dir
+   * @return {Promise<ExtendedInfo>}
+   */
+  getExtendedInfo: async function (folderPath) {
+    const info = {
+      totalSize: 0,
+      fileCount: 0,
+      totalFileCount: 0,
+      folderCount: 0,
+      totalFolderCount: 0,
+      lastModified: 0
+    }
+
+    await dirList._getExtendedInfo(folderPath, info)
+
+    return info
+  },
+
   /**
    * get files and dirs from dir, or error
    * @param {string} dir full path fs dir
@@ -22,8 +72,7 @@ const dirList = {
       return entries
     }
 
-    const limit = pLimit(4)
-    await Promise.all(files.map(filename => limit(async () => {
+    const worker = async (filename) => {
       let stats
       try {
         stats = await fs.stat(path.join(dir, filename))
@@ -33,62 +82,15 @@ const dirList = {
       const entry = { name: filename, stats }
       if (stats.isDirectory()) {
         if (options.extendedFolderInfo) {
-          entry.extendedInfo = await getExtendedInfo(path.join(dir, filename))
+          entry.extendedInfo = await dirList.getExtendedInfo(path.join(dir, filename))
         }
         entries.dirs.push(entry)
       } else {
         entries.files.push(entry)
       }
-    })))
-
-    async function getExtendedInfo (folderPath) {
-      const depth = folderPath.split(path.sep).length
-      let totalSize = 0
-      let fileCount = 0
-      let totalFileCount = 0
-      let folderCount = 0
-      let totalFolderCount = 0
-      let lastModified = 0
-
-      async function walk (dir) {
-        const files = await fs.readdir(dir)
-        const limit = pLimit(4)
-        await Promise.all(files.map(filename => limit(async () => {
-          const filePath = path.join(dir, filename)
-          let stats
-          try {
-            stats = await fs.stat(filePath)
-          } catch {
-            return
-          }
-
-          if (stats.isDirectory()) {
-            totalFolderCount++
-            if (filePath.split(path.sep).length === depth + 1) {
-              folderCount++
-            }
-            await walk(filePath)
-          } else {
-            totalSize += stats.size
-            totalFileCount++
-            if (filePath.split(path.sep).length === depth + 1) {
-              fileCount++
-            }
-            lastModified = Math.max(lastModified, stats.mtimeMs)
-          }
-        })))
-      }
-
-      await walk(folderPath)
-      return {
-        totalSize,
-        fileCount,
-        totalFileCount,
-        folderCount,
-        totalFolderCount,
-        lastModified
-      }
     }
+    const queue = fastq.promise(worker, fastqConcurrency)
+    await Promise.all(files.map(filename => queue.push(filename)))
 
     entries.dirs.sort((a, b) => a.name.localeCompare(b.name))
     entries.files.sort((a, b) => a.name.localeCompare(b.name))
@@ -115,6 +117,7 @@ const dirList = {
     } catch {
       return reply.callNotFound()
     }
+
     const format = reply.request.query.format || options.format
     if (format !== 'html') {
       if (options.jsonFormat !== 'extended') {
@@ -203,7 +206,6 @@ const dirList = {
       return new TypeError('The `list.render` option must be a function and is required with html format')
     }
   }
-
 }
 
 module.exports = dirList

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/static",
-  "version": "6.12.0",
+  "version": "7.0.1",
   "description": "Plugin for serving static files as fast as possible.",
   "main": "index.js",
   "type": "commonjs",
@@ -18,7 +18,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/fastify/fastify-static.git"
+    "url": "git+https://github.com/fastify/fastify-static.git"
   },
   "keywords": [
     "fastify",
@@ -35,11 +35,11 @@
     "@fastify/send": "^2.0.0",
     "content-disposition": "^0.5.3",
     "fastify-plugin": "^4.0.0",
-    "glob": "^8.0.1",
-    "p-limit": "^3.1.0"
+    "fastq": "^1.17.0",
+    "glob": "^10.3.4"
   },
   "devDependencies": {
-    "@fastify/compress": "^6.0.0",
+    "@fastify/compress": "^7.0.0",
     "@fastify/pre-commit": "^2.0.2",
     "@types/node": "^20.1.0",
     "@typescript-eslint/eslint-plugin": "^6.3.0",
@@ -55,7 +55,7 @@
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "tsd": "^0.29.0",
+    "tsd": "^0.30.0",
     "typescript": "^5.1.6"
   },
   "tsd": {

package/test/static.test.js

@@ -2012,6 +2012,96 @@ t.test('register with wildcard false', t => {
   })
 })
 
+t.test('register with wildcard false (trailing slash in the root)', t => {
+  t.plan(6)
+
+  const pluginOptions = {
+    root: path.join(__dirname, '/static/'),
+    prefix: '/assets/',
+    index: false,
+    wildcard: false
+  }
+  const fastify = Fastify({
+    ignoreTrailingSlash: true
+  })
+  fastify.register(fastifyStatic, pluginOptions)
+
+  fastify.get('/*', (request, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    fastify.server.unref()
+
+    t.test('/index.css', (t) => {
+      t.plan(2 + GENERIC_RESPONSE_CHECK_COUNT)
+      simple.concat({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        genericResponseChecks(t, response)
+      })
+    })
+
+    t.test('/not-defined', (t) => {
+      t.plan(3)
+      simple.concat({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/assets/not-defined'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+
+    t.test('/deep/path/for/test/purpose/foo.html', (t) => {
+      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+      simple.concat({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/assets/deep/path/for/test/purpose/foo.html'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.equal(body.toString(), deepContent)
+        genericResponseChecks(t, response)
+      })
+    })
+
+    t.test('/../index.js', (t) => {
+      t.plan(3)
+      simple.concat({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/assets/../index.js',
+        followRedirect: false
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(JSON.parse(body), { hello: 'world' })
+      })
+    })
+
+    t.test('/index.css', t => {
+      t.plan(3 + GENERIC_RESPONSE_CHECK_COUNT)
+      simple.concat({
+        method: 'HEAD',
+        url: 'http://localhost:' + fastify.server.address().port + '/assets/index.css'
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.equal(body.toString(), '')
+        genericResponseChecks(t, response)
+      })
+    })
+  })
+})
+
 t.test('register with wildcard string', (t) => {
   t.plan(1)
 

package/types/index.d.ts

@@ -2,7 +2,7 @@
 //                 Leo <https://github.com/leomelzer>
 /// <reference types="node" />
 
-import { FastifyPluginAsync, FastifyRequest, RouteOptions } from 'fastify'
+import { FastifyPluginAsync, FastifyReply, FastifyRequest, RouteOptions } from 'fastify'
 import { Stats } from 'fs'
 
 declare module 'fastify' {
@@ -19,6 +19,13 @@ declare module 'fastify' {
 type FastifyStaticPlugin = FastifyPluginAsync<NonNullable<fastifyStatic.FastifyStaticOptions>>;
 
 declare namespace fastifyStatic {
+  export interface SetHeadersResponse {
+    getHeader: FastifyReply['getHeader'];
+    setHeader: FastifyReply['header'];
+    readonly filename: string;
+    statusCode: number;
+  }
+
   export interface ExtendedInformation {
     fileCount: number;
     totalFileCount: number;
@@ -83,7 +90,7 @@ declare namespace fastifyStatic {
     serve?: boolean;
     decorateReply?: boolean;
     schemaHide?: boolean;
-    setHeaders?: (...args: any[]) => void;
+    setHeaders?: (res: SetHeadersResponse, path: string, stat: Stats) => void;
     redirect?: boolean;
     wildcard?: boolean;
     list?: boolean | ListOptionsJsonFormat | ListOptionsHtmlFormat;

package/types/index.test-d.ts

@@ -1,5 +1,6 @@
-import fastify, { FastifyInstance, FastifyPluginAsync, FastifyRequest } from 'fastify'
+import fastify, { FastifyInstance, FastifyPluginAsync, FastifyRequest, FastifyReply } from 'fastify'
 import { Server } from 'http'
+import { Stats } from 'fs'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import * as fastifyStaticStar from '..'
 import fastifyStatic, {
@@ -49,8 +50,15 @@ const options: FastifyStaticOptions = {
   serve: true,
   wildcard: true,
   list: false,
-  setHeaders: (res: any, pathName: any) => {
-    res.setHeader('test', pathName)
+  setHeaders: (res, path, stat) => {
+    expectType<string>(res.filename)
+    expectType<number>(res.statusCode)
+    expectType<ReturnType<FastifyReply['getHeader']>>(res.getHeader('X-Test'))
+    res.setHeader('X-Test', 'string')
+
+    expectType<string>(path)
+
+    expectType<Stats>(stat)
   },
   preCompressed: false,
   allowedPath: (pathName: string, root: string, request: FastifyRequest) => {