fastify 6.0.0-alpha.1 → 6.0.0-alpha.2

package/lib/route.js

@@ -289,6 +289,7 @@ function buildRouting (options) {
         opts.attachValidation = false
       }
 
+      const routeConfigUrl = prefixing ? prefix : url
       if (prefixing === false) {
         // run 'onRoute' hooks
         for (const hook of this[kHooks].onRoute) {
@@ -327,7 +328,7 @@ function buildRouting (options) {
       const constraints = opts.constraints || {}
       const config = {
         ...opts.config,
-        url,
+        url: routeConfigUrl,
         method: opts.method
       }
 

package/lib/validation.js

@@ -120,7 +120,16 @@ function validateParam (validatorFunction, request, paramName) {
   let ret
 
   try {
-    ret = validatorFunction?.(isUndefined ? null : request[paramName])
+    const data = isUndefined ? null : request[paramName]
+    // Ajv can only mutate a root value when its parent is provided.
+    if (validatorFunction?.schemaEnv) {
+      ret = validatorFunction(data, {
+        parentData: request,
+        parentDataProperty: paramName
+      })
+    } else {
+      ret = validatorFunction?.(data)
+    }
   } catch (err) {
     // If validator throws synchronously, ensure it propagates as an internal error
     err.statusCode = 500

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "6.0.0-alpha.1",
+  "version": "6.0.0-alpha.2",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

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

@@ -569,6 +569,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

@@ -194,6 +194,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({ routerOptions: { querystringParser: () => ({ foo: 'bar' }) } })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ routerOptions: { querystringParser: () => ({ foo: { bar: 'fuzz' } }) } })).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ routerOptions: { querystringParser: () => ({ foo: ['bar', 'fuzz'] }) } })).type.toBeAssignableTo<FastifyInstance>()