@fastify/static 9.1.1 → 9.1.3

package/example/server-benchmark.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const path = require('node:path')
+const fastify = require('fastify')({ logger: false })
+const fastifyStatic = require(process.env.PLUGIN_PATH || '../')
+
+const root = path.join(__dirname, '/public')
+const port = Number(process.env.PORT || 3000)
+
+fastify.register(fastifyStatic, {
+  root,
+  prefix: '/static',
+  decorateReply: false
+})
+
+fastify.register(fastifyStatic, {
+  root,
+  prefix: '/app/:version',
+  decorateReply: false
+})
+
+fastify.register(async function (child) {
+  child.register(fastifyStatic, {
+    root,
+    prefix: '/public',
+    decorateReply: false
+  })
+}, { prefix: '/nested' })
+
+fastify.listen({ port }, err => {
+  if (err) throw err
+
+  console.log(`benchmark server listening on http://127.0.0.1:${port}`)
+  console.log('')
+  console.log('Try:')
+  console.log(`  npx autocannon -c 100 -d 10 http://127.0.0.1:${port}/static/index.css`)
+  console.log(`  npx autocannon -c 100 -d 10 http://127.0.0.1:${port}/app/1.2.3/index.css`)
+  console.log(`  npx autocannon -c 100 -d 10 http://127.0.0.1:${port}/nested/public/index.css`)
+})

package/index.js

@@ -117,12 +117,16 @@ async function fastifyStatic (fastify, opts) {
       throw new TypeError('"wildcard" option must be a boolean')
     }
     if (opts.wildcard === undefined || opts.wildcard === true) {
+      let matchRoutePrefix
+
       fastify.route({
         ...routeOpts,
         method: ['HEAD', 'GET'],
         path: prefix + '*',
         handler (req, reply) {
-          const pathname = getPathnameForSend(req.raw.url, prefix)
+          matchRoutePrefix ??= createRoutePrefixMatcher(req.routeOptions.url)
+
+          const pathname = getPathnameForSend(req.raw.url, matchRoutePrefix)
           if (!pathname) {
             return reply.callNotFound()
           }
@@ -569,26 +573,114 @@ function getEncodingHeader (headers, checked) {
 }
 
 /**
- * @param {string} url
- * @param {string} prefix
- * @returns {string|undefined}
+ * @param {string} routePrefix
+ * @returns {Array<string|undefined>}
  */
-function getPathnameForSend (url, prefix) {
-  const questionMark = url.indexOf('?')
-  let pathname = questionMark === -1 ? url : url.slice(0, questionMark)
+function createRoutePrefixTokens (routePrefix) {
+  const tokens = []
+  let routeIndex = 0
+  let segmentStart = 0
+
+  while (routeIndex < routePrefix.length) {
+    if (routePrefix[routeIndex] !== ':') {
+      routeIndex++
+      continue
+    }
+
+    if (segmentStart !== routeIndex) {
+      tokens.push(routePrefix.slice(segmentStart, routeIndex))
+    }
+
+    routeIndex++
+    while (routeIndex < routePrefix.length && routePrefix[routeIndex] !== '/') {
+      routeIndex++
+    }
+
+    tokens.push(undefined)
+    segmentStart = routeIndex
+  }
 
-  if (prefix !== '/') {
-    const routePrefix = prefix.endsWith('/')
-      ? prefix.slice(0, -1)
-      : prefix
+  if (segmentStart !== routePrefix.length) {
+    tokens.push(routePrefix.slice(segmentStart))
+  }
+
+  return tokens
+}
+
+/**
+ * @param {string} pathname
+ * @param {number} pathnameEnd
+ * @param {Array<string|undefined>} tokens
+ * @returns {number|undefined}
+ */
+function getRoutePrefixMatchLength (pathname, pathnameEnd, tokens) {
+  let pathnameIndex = 0
+
+  for (const token of tokens) {
+    if (token === undefined) {
+      const segmentStart = pathnameIndex
+      const slashIndex = pathname.indexOf('/', pathnameIndex)
+
+      pathnameIndex = slashIndex === -1 || slashIndex > pathnameEnd
+        ? pathnameEnd
+        : slashIndex
+
+      if (pathnameIndex === segmentStart) {
+        return
+      }
 
-    if (!pathname.startsWith(routePrefix)) {
+      continue
+    }
+
+    const tokenEnd = pathnameIndex + token.length
+    if (tokenEnd > pathnameEnd || !pathname.startsWith(token, pathnameIndex)) {
       return
     }
 
-    pathname = pathname.slice(routePrefix.length)
+    pathnameIndex = tokenEnd
+  }
+
+  return pathnameIndex
+}
+
+/**
+ * @param {string} route
+ * @returns {(pathname: string, pathnameEnd: number) => number|undefined}
+ */
+function createRoutePrefixMatcher (route) {
+  const routePrefix = route.replace(/\*$/u, '')
+  const routePrefixLength = routePrefix.length
+
+  if (routePrefix === '/') {
+    return () => 0
   }
 
+  if (routePrefix.includes(':') === false) {
+    return (pathname, pathnameEnd) => routePrefixLength <= pathnameEnd && pathname.startsWith(routePrefix)
+      ? routePrefixLength
+      : undefined
+  }
+
+  const tokens = createRoutePrefixTokens(routePrefix)
+  return (pathname, pathnameEnd) => getRoutePrefixMatchLength(pathname, pathnameEnd, tokens)
+}
+
+/**
+ * @param {string} url
+ * @param {(pathname: string, pathnameEnd: number) => number|undefined} matchRoutePrefix
+ * @returns {string|undefined}
+ */
+function getPathnameForSend (url, matchRoutePrefix) {
+  const questionMark = url.indexOf('?')
+  const pathnameEnd = questionMark === -1 ? url.length : questionMark
+
+  const prefixLength = matchRoutePrefix(url, pathnameEnd)
+  if (prefixLength === undefined) {
+    return
+  }
+
+  let pathname = url.slice(prefixLength, pathnameEnd)
+
   if (pathname === '') {
     pathname = '/'
   } else if (!pathname.startsWith('/')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/static",
-  "version": "9.1.1",
+  "version": "9.1.3",
   "description": "Plugin for serving static files as fast as possible.",
   "main": "index.js",
   "type": "commonjs",
@@ -12,7 +12,8 @@
     "test": "npm run test:unit && npm run test:typescript",
     "test:typescript": "tsd",
     "test:unit": "borp -C --check-coverage --lines 100",
-    "example": "node example/server.js"
+    "example": "node example/server.js",
+    "example:benchmark": "node example/server-benchmark.js"
   },
   "repository": {
     "type": "git",
@@ -68,6 +69,7 @@
   "devDependencies": {
     "@fastify/compress": "^8.0.0",
     "@types/node": "^25.0.3",
+    "autocannon": "^8.0.0",
     "borp": "^1.0.0",
     "c8": "^11.0.0",
     "concat-stream": "^2.0.0",

package/test/static.test.js

@@ -3590,6 +3590,146 @@ test(
   }
 )
 
+test('wildcard handler falls back to not found when the raw url does not match the route prefix', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  let wildcardHandler
+
+  fastify.addHook('onRoute', (route) => {
+    if (route.url === '/static/*') {
+      wildcardHandler = route.handler
+    }
+  })
+
+  fastify.register(fastifyStatic, {
+    root: path.join(__dirname, '/static'),
+    prefix: '/static'
+  })
+
+  t.after(() => fastify.close())
+
+  await fastify.ready()
+  t.assert.ok(wildcardHandler)
+
+  let notFoundCalled = false
+  await wildcardHandler({
+    raw: { url: '/nested/static/index.css' },
+    routeOptions: { url: '/static/*' }
+  }, {
+    callNotFound () {
+      notFoundCalled = true
+    }
+  })
+
+  t.assert.deepStrictEqual(notFoundCalled, true)
+})
+
+test('wildcard handler falls back to not found when a param segment is empty', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  let wildcardHandler
+
+  fastify.addHook('onRoute', (route) => {
+    if (route.url === '/app/:version/*') {
+      wildcardHandler = route.handler
+    }
+  })
+
+  fastify.register(fastifyStatic, {
+    root: path.join(__dirname, '/static'),
+    prefix: '/app/:version'
+  })
+
+  t.after(() => fastify.close())
+
+  await fastify.ready()
+  t.assert.ok(wildcardHandler)
+
+  let notFoundCalled = false
+  await wildcardHandler({
+    raw: { url: '/app//index.css' },
+    routeOptions: { url: '/app/:version/*' }
+  }, {
+    callNotFound () {
+      notFoundCalled = true
+    }
+  })
+
+  t.assert.deepStrictEqual(notFoundCalled, true)
+})
+
+test('wildcard handler falls back to not found when the wildcard remainder is malformed', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  let wildcardHandler
+
+  fastify.addHook('onRoute', (route) => {
+    if (route.url === '/app/:version/*') {
+      wildcardHandler = route.handler
+    }
+  })
+
+  fastify.register(fastifyStatic, {
+    root: path.join(__dirname, '/static'),
+    prefix: '/app/:version'
+  })
+
+  t.after(() => fastify.close())
+
+  await fastify.ready()
+  t.assert.ok(wildcardHandler)
+
+  let notFoundCalled = false
+  await wildcardHandler({
+    raw: { url: '/app/1.2.3/%E0%A4%A' },
+    routeOptions: { url: '/app/:version/*' }
+  }, {
+    callNotFound () {
+      notFoundCalled = true
+    }
+  })
+
+  t.assert.deepStrictEqual(notFoundCalled, true)
+})
+
+test('wildcard handler falls back to not found when a literal segment after a param does not match', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  let wildcardHandler
+
+  fastify.addHook('onRoute', (route) => {
+    if (route.url === '/app/:version/public/*') {
+      wildcardHandler = route.handler
+    }
+  })
+
+  fastify.register(fastifyStatic, {
+    root: path.join(__dirname, '/static'),
+    prefix: '/app/:version/public'
+  })
+
+  t.after(() => fastify.close())
+
+  await fastify.ready()
+  t.assert.ok(wildcardHandler)
+
+  let notFoundCalled = false
+  await wildcardHandler({
+    raw: { url: '/app/1.2.3/private/index.css' },
+    routeOptions: { url: '/app/:version/public/*' }
+  }, {
+    callNotFound () {
+      notFoundCalled = true
+    }
+  })
+
+  t.assert.deepStrictEqual(notFoundCalled, true)
+})
+
 test('does not serve static files with encoded path separators', async (t) => {
   t.plan(4)
 
@@ -3620,6 +3760,78 @@ test('does not serve static files with encoded path separators', async (t) => {
   t.assert.deepStrictEqual(encodedPathResponse.json().message, 'Route GET:/deep%2Fpath/for/test/purpose/foo.html not found')
 })
 
+test('serves wildcard files when registered in an encapsulated context', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  t.after(() => fastify.close())
+
+  fastify.register(async function (childContext) {
+    childContext.register(fastifyStatic, {
+      root: path.join(__dirname, '/static'),
+      prefix: '/public',
+      decorateReply: false
+    })
+  }, { prefix: '/nested' })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/nested/public/index.css'
+  })
+
+  t.assert.deepStrictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.headers['content-type'], 'text/css; charset=utf-8')
+  t.assert.deepStrictEqual(response.body, fs.readFileSync(path.join(__dirname, '/static/index.css'), 'utf8'))
+})
+
+test('serves wildcard files when prefix contains a route param', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  t.after(() => fastify.close())
+
+  fastify.register(fastifyStatic, {
+    root: path.join(__dirname, '/static'),
+    prefix: '/app/:version',
+    decorateReply: false
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/app/1.2.3/index.css'
+  })
+
+  t.assert.deepStrictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.headers['content-type'], 'text/css; charset=utf-8')
+  t.assert.deepStrictEqual(response.body, fs.readFileSync(path.join(__dirname, '/static/index.css'), 'utf8'))
+})
+
+test('serves wildcard index files when a param prefix uses prefixAvoidTrailingSlash', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  t.after(() => fastify.close())
+
+  fastify.register(fastifyStatic, {
+    root: path.join(__dirname, '/static'),
+    prefix: '/app/:version',
+    prefixAvoidTrailingSlash: true,
+    decorateReply: false
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/app/1.2.3'
+  })
+
+  t.assert.deepStrictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.headers['content-type'], 'text/html; charset=utf-8')
+  t.assert.deepStrictEqual(response.body, fs.readFileSync(path.join(__dirname, '/static/index.html'), 'utf8'))
+})
+
 test('content-length in head route should not return zero when using wildcard', async t => {
   t.plan(5)
 

package/test/static/shallow/no-link

@@ -1 +0,0 @@
-/none

package/test/static-symbolic-link/dir/symlink

@@ -1 +0,0 @@
-../origin