fastify 5.12.0 → 5.12.1

package/test/close.test.js

@@ -665,6 +665,40 @@ test('preClose async', async t => {
   await fastify.close()
 })
 
+test('preClose runs exactly once with a child plugin', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  let count = 0
+
+  fastify.register(async (child) => {
+    child.get('/x', async () => 'ok')
+  })
+  fastify.addHook('preClose', async () => { count++ })
+
+  await fastify.ready()
+  await fastify.close()
+
+  t.assert.strictEqual(count, 1)
+})
+
+test('preClose runs exactly once with nested child plugins', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  let count = 0
+
+  fastify.register(async (child) => {
+    child.register(async (grandchild) => {
+      grandchild.get('/y', async () => 'ok')
+    })
+  })
+  fastify.addHook('preClose', async () => { count++ })
+
+  await fastify.ready()
+  await fastify.close()
+
+  t.assert.strictEqual(count, 1)
+})
+
 test('preClose execution order', (t, done) => {
   t.plan(4)
   const fastify = Fastify()

package/test/fix-root-primitive-coercion.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('root primitive values coerced by Ajv are assigned to the request', async (t) => {
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema: {
+      body: {
+        type: 'integer',
+        minimum: 1,
+        maximum: 10
+      }
+    }
+  }, (request, reply) => {
+    reply.send({ body: request.body, type: typeof request.body })
+  })
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: '"10"',
+    headers: { 'content-type': 'application/json' }
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(JSON.parse(response.payload), {
+    body: 10,
+    type: 'number'
+  })
+
+  await fastify.close()
+})

package/test/internals/reply.test.js

@@ -49,7 +49,7 @@ test('Once called, Reply should return an object with methods', t => {
   t.assert.strictEqual(typeof reply[kReplyErrorHandlerCalled], 'boolean')
   t.assert.strictEqual(typeof reply.send, 'function')
   t.assert.strictEqual(typeof reply.code, 'function')
-  t.assert.strictEqual(typeof reply.mediaType, 'string')
+  t.assert.strictEqual(typeof reply.mediaType, 'undefined')
   t.assert.strictEqual(typeof reply.status, 'function')
   t.assert.strictEqual(typeof reply.header, 'function')
   t.assert.strictEqual(typeof reply.serialize, 'function')

package/test/route-prefix.test.js

@@ -563,6 +563,38 @@ test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "
   completion.patience.then(testDone)
 })
 
+test('reports the canonical route url for hidden prefix trailing slash route', async t => {
+  t.plan(4)
+
+  const fastify = Fastify({
+    ignoreTrailingSlash: false,
+    exposeHeadRoutes: false
+  })
+
+  const onRouteUrls = []
+
+  fastify.addHook('onRoute', routeOptions => {
+    onRouteUrls.push(routeOptions.url)
+  })
+
+  fastify.register(async instance => {
+    instance.get('/', async request => {
+      return request.routeOptions.url
+    })
+
+    instance.get('/bar/', async request => {
+      return request.routeOptions.url
+    })
+  }, { prefix: '/prefix' })
+
+  t.assert.strictEqual((await fastify.inject('/prefix')).payload, '/prefix')
+  t.assert.strictEqual((await fastify.inject('/prefix/')).payload, '/prefix')
+  t.assert.strictEqual((await fastify.inject('/prefix/bar/')).payload, '/prefix/bar/')
+  t.assert.deepStrictEqual(onRouteUrls, ['/prefix', '/prefix/bar/'])
+
+  await fastify.close()
+})
+
 test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreDuplicateSlashes: false', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify({

package/test/trust-proxy.test.js

@@ -106,20 +106,33 @@ test('trust proxy function', async t => {
   await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined, 'fastify.test:1234')
 })
 
-test('trust proxy number', async t => {
-  t.plan(8)
+test('trust proxy number ignores forwarded headers', async t => {
+  t.plan(5)
   const app = fastify({
     trustProxy: 1
   })
   t.after(() => app.close())
 
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
+    t.assert.strictEqual(req.ip, '203.0.113.7', 'ip falls back to socket remote address')
+    t.assert.deepStrictEqual(req.ips, ['203.0.113.7'], 'ips falls back to socket remote address')
+    t.assert.strictEqual(req.host, 'app.example.com', 'host ignores x-forwarded-host')
+    t.assert.strictEqual(req.hostname, 'app.example.com', 'hostname ignores x-forwarded-host')
+    t.assert.strictEqual(req.protocol, 'http', 'protocol ignores x-forwarded-proto')
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  const fastifyServer = await app.listen({ port: 0 })
-  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, 'fastify.test:1234')
+  await app.inject({
+    method: 'GET',
+    url: '/trustproxynumber',
+    remoteAddress: '203.0.113.7',
+    headers: {
+      host: 'app.example.com',
+      'x-forwarded-for': '9.9.9.9, 8.8.8.8',
+      'x-forwarded-host': 'evil.com',
+      'x-forwarded-proto': 'https'
+    }
+  })
 })
 
 test('trust proxy IP addresses', async t => {
@@ -241,18 +254,15 @@ test('trust proxy reads forwarded headers from trusted connections', async t =>
   })
 })
 
-test('trust proxy with number and undefined socket remoteAddress', t => {
+test('trust proxy with number and undefined socket remoteAddress ignores forwarded headers', t => {
   t.plan(3)
 
-  // Test case for issue #6606: trustProxy: 1 with undefined/null socket.remoteAddress
-  // This simulates IISNode on Windows where socket.remoteAddress may be undefined
   const headers = {
+    host: 'real.test',
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
     'x-forwarded-host': 'fastify.test',
     'x-forwarded-proto': 'https'
   }
-  // socket must exist but remoteAddress can be undefined
-  // This is what happens in IISNode with enableXFF="true"
   const req = {
     method: 'GET',
     url: '/',
@@ -262,20 +272,16 @@ test('trust proxy with number and undefined socket remoteAddress', t => {
 
   const TpRequest = buildRequest(Request, 1)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  // Even with undefined socket.remoteAddress, req.ip should be populated from X-Forwarded-For
-  t.assert.ok(request.ip, 'ip is defined')
-  // With trustProxy: 1, we trust 1 hop from socket. Since socket.remoteAddress is undefined,
-  // the hop count check should skip it and we get 1.1.1.1 (the first trusted address from X-Forwarded-For)
-  t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
-  // The host should also work correctly
-  t.assert.strictEqual(request.host, 'fastify.test', 'gets host from x-forwarded-host')
+  t.assert.strictEqual(request.ip, undefined, 'ip falls back to undefined socket remote address')
+  t.assert.strictEqual(request.host, 'real.test', 'host ignores x-forwarded-host')
+  t.assert.strictEqual(request.protocol, 'http', 'protocol ignores x-forwarded-proto')
 })
 
-test('trust proxy with number and null socket remoteAddress', t => {
+test('trust proxy with number and null socket remoteAddress ignores forwarded headers', t => {
   t.plan(2)
 
-  // Test case for trustProxy: 1 with null socket.remoteAddress
   const headers = {
+    host: 'real.test',
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
     'x-forwarded-host': 'fastify.test'
   }
@@ -288,8 +294,8 @@ test('trust proxy with number and null socket remoteAddress', t => {
 
   const TpRequest = buildRequest(Request, 1)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.assert.ok(request.ip, 'ip is defined')
-  t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
+  t.assert.strictEqual(request.ip, null, 'ip falls back to null socket remote address')
+  t.assert.strictEqual(request.host, 'real.test', 'host ignores x-forwarded-host')
 })
 
 test('trust proxy does not trust x-forwarded-host/proto when socket is null', t => {

package/test/types/fastify.tst.ts

@@ -198,6 +198,8 @@ expect(fastify({
   }
 })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ trustProxy: true })).type.toBeAssignableTo<FastifyInstance>()
+// @ts-expect-error  No overload matches this call.
+fastify({ trustProxy: 1 })
 expect(fastify({ querystringParser: () => ({ foo: 'bar' }) })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ querystringParser: () => ({ foo: { bar: 'fuzz' } }) })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ querystringParser: () => ({ foo: ['bar', 'fuzz'] }) })).type.toBeAssignableTo<FastifyInstance>()