fastify 4.28.0 → 4.29.0

package/test/json-shorthand.test.js

@@ -0,0 +1,131 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+const {
+  FSTDEP022
+} = require('../lib/warnings')
+
+test('use of deprecated json shorthand in params should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    schema: {
+      params: {
+        id: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'GET', url: '/1' }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})
+
+test('use of deprecated json shorthand in headers should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    schema: {
+      headers: {
+        hello: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})
+
+test('use of deprecated json shorthand in querystring should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    schema: {
+      querystring: {
+        hello: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'GET', url: '/', query: { hello: 'world' } }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})
+
+test('use of deprecated json shorthand in body should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema: {
+      body: {
+        hello: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'POST', url: '/', body: { hello: 'world' } }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})

package/test/listen.1.test.js

@@ -99,3 +99,39 @@ test('listen after Promise.resolve()', t => {
       })
     })
 })
+
+test('listen works with undefined host', async t => {
+  const doNotWarn = () => {
+    t.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  t.teardown(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen({ host: undefined, port: 0 })
+  const address = fastify.server.address()
+  t.equal(address.address, localhost)
+  t.ok(address.port > 0)
+})
+
+test('listen works with null host', async t => {
+  const doNotWarn = () => {
+    t.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  t.teardown(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen({ host: null, port: 0 })
+  const address = fastify.server.address()
+  t.equal(address.address, localhost)
+  t.ok(address.port > 0)
+})

package/test/listen.5.test.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const { test } = require('tap')
+const net = require('node:net')
+const Fastify = require('../fastify')
+const { once } = require('node:events')
+
+function createDeferredPromise () {
+  const promise = {}
+  promise.promise = new Promise((resolve) => {
+    promise.resolve = resolve
+  })
+  return promise
+}
+
+test('same port conflict and success should not fire callback multiple times - callback', async (t) => {
+  t.plan(7)
+  const server = net.createServer()
+  server.listen({ port: 0, host: '127.0.0.1' })
+  await once(server, 'listening')
+  const option = { port: server.address().port, host: server.address().address }
+  let count = 0
+  const fastify = Fastify()
+  const promise = createDeferredPromise()
+  function callback (err) {
+    switch (count) {
+      case 6: {
+        // success in here
+        t.error(err)
+        fastify.close((err) => {
+          t.error(err)
+          promise.resolve()
+        })
+        break
+      }
+      case 5: {
+        server.close()
+        setTimeout(() => {
+          fastify.listen(option, callback)
+        }, 100)
+        break
+      }
+      default: {
+        // expect error
+        t.equal(err.code, 'EADDRINUSE')
+        setTimeout(() => {
+          fastify.listen(option, callback)
+        }, 100)
+      }
+    }
+    count++
+  }
+  fastify.listen(option, callback)
+  await promise.promise
+})
+
+test('same port conflict and success should not fire callback multiple times - promise', async (t) => {
+  t.plan(5)
+  const server = net.createServer()
+  server.listen({ port: 0, host: '127.0.0.1' })
+  await once(server, 'listening')
+  const option = { port: server.address().port, host: server.address().address }
+  const fastify = Fastify()
+
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+  try {
+    await fastify.listen(option)
+  } catch (err) {
+    t.equal(err.code, 'EADDRINUSE')
+  }
+
+  server.close()
+
+  await once(server, 'close')
+
+  // when ever we can listen, and close properly
+  // which means there is no problem on the callback
+  await fastify.listen()
+  await fastify.close()
+})

package/test/mkcol.test.js

@@ -12,7 +12,7 @@ test('can be created - mkcol', t => {
       method: 'MKCOL',
       url: '*',
       handler: function (req, reply) {
-        reply.code(201).send()
+        reply.code(201).header('body', req.body.toString()).send()
       }
     })
     t.pass()
@@ -26,12 +26,15 @@ fastify.listen({ port: 0 }, err => {
   t.teardown(() => { fastify.close() })
 
   test('request - mkcol', t => {
-    t.plan(2)
+    t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test/`,
-      method: 'MKCOL'
-    }, (err, response, body) => {
+      method: 'MKCOL',
+      headers: { 'Content-Type': 'text/plain' },
+      body: '/test.txt'
+    }, (err, response) => {
       t.error(err)
+      t.equal(response.headers.body, '/test.txt')
       t.equal(response.statusCode, 201)
     })
   })

package/test/move.test.js

@@ -12,9 +12,9 @@ test('shorthand - move', t => {
       method: 'MOVE',
       url: '*',
       handler: function (req, reply) {
-        const destination = req.headers.destination
         reply.code(201)
-          .header('location', destination)
+          .header('location', req.headers.destination)
+          .header('body', req.body.toString())
           .send()
       }
     })
@@ -29,17 +29,20 @@ fastify.listen({ port: 0 }, err => {
   t.teardown(() => { fastify.close() })
 
   test('request - move', t => {
-    t.plan(3)
+    t.plan(4)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test.txt`,
       method: 'MOVE',
       headers: {
-        Destination: '/test2.txt'
-      }
-    }, (err, response, body) => {
+        destination: '/test2.txt',
+        'Content-Type': 'text/plain'
+      },
+      body: '/test3.txt'
+    }, (err, response) => {
       t.error(err)
       t.equal(response.statusCode, 201)
       t.equal(response.headers.location, '/test2.txt')
+      t.equal(response.headers.body, '/test3.txt')
     })
   })
 })

package/test/route.8.test.js

@@ -140,3 +140,30 @@ test('using fastify.all when a catchall is defined does not degrade performance'
 
   t.pass()
 })
+
+test('Adding manually HEAD route after GET with the same path throws Fastify duplicated route instance error', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    path: '/:param1',
+    handler: (req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  try {
+    fastify.route({
+      method: 'HEAD',
+      path: '/:param2',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+    t.fail('Should throw fastify duplicated route declaration')
+  } catch (error) {
+    t.equal(error.code, 'FST_ERR_DUPLICATED_ROUTE')
+  }
+})

package/test/schema-feature.test.js

@@ -190,6 +190,27 @@ test('Should throw of the schema does not exists in input', t => {
   })
 })
 
+test('Should throw if schema is missing for content type', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    handler: echoBody,
+    schema: {
+      body: {
+        content: {
+          'application/json': {}
+        }
+      }
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_CONTENT_MISSING_SCHEMA')
+    t.equal(err.message, "Schema is missing for the content type 'application/json'")
+  })
+})
+
 test('Should throw of the schema does not exists in output', t => {
   t.plan(2)
   const fastify = Fastify()

package/test/schema-validation.test.js

@@ -105,6 +105,142 @@ test('Basic validation test', t => {
   })
 })
 
+test('Different schema per content type', t => {
+  t.plan(12)
+
+  const fastify = Fastify()
+  fastify.addContentTypeParser('application/octet-stream', {
+    parseAs: 'buffer'
+  }, async function (_, payload) {
+    return payload
+  })
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: schemaArtist
+          },
+          'application/octet-stream': {
+            schema: {} // Skip validation
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: {
+      name: 'michelangelo',
+      work: 'sculptor, painter, architect and poet'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload).name, 'michelangelo')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: { name: 'michelangelo' }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
+    t.equal(res.statusCode, 400)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: Buffer.from('AAAAAAAA')
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Skip validation if no schema for content type', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: schemaArtist
+          }
+          // No schema for 'text/plain'
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Skip validation if no content type schemas', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          // No schemas
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
 test('External AJV instance', t => {
   t.plan(5)
 

package/test/stream-serializers.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const Reply = require('../lib/reply')
+
+test('should serialize reply when response stream is ended', t => {
+  t.plan(3)
+  const stream = require('node:stream')
+  const fastify = Fastify({
+    logger: {
+      serializers: {
+        res (reply) {
+          t.type(reply, Reply)
+          return reply
+        }
+      }
+    }
+  })
+
+  fastify.get('/error', function (req, reply) {
+    const reallyLongStream = new stream.Readable({
+      read: () => { }
+    })
+    reply.code(200).send(reallyLongStream)
+    reply.raw.end(Buffer.from('hello\n'))
+  })
+
+  fastify.inject({
+    url: '/error',
+    method: 'GET'
+  }, (err) => {
+    t.error(err)
+    fastify.close()
+  })
+})

package/test/throw.test.js

@@ -22,9 +22,9 @@ test('Fastify should throw on multiple assignment to the same route', t => {
 
   try {
     fastify.get('/', () => {})
-    t.fail('Should throw on duplicated route declaration')
+    t.fail('Should throw fastify duplicated route declaration')
   } catch (error) {
-    t.equal(error.message, "Method 'GET' already declared for route '/'")
+    t.equal(error.code, 'FST_ERR_DUPLICATED_ROUTE')
   }
 })
 

package/test/types/hooks.test-d.ts

@@ -151,7 +151,8 @@ server.addHook('onListen', function (done) {
   expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
 })
 
-server.addHook('onClose', (instance, done) => {
+server.addHook('onClose', function (instance, done) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
   expectAssignable<(err?: FastifyError) => void>(done)
   expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
@@ -236,7 +237,8 @@ server.addHook('onListen', async function () {
   expectType<FastifyInstance>(this)
 })
 
-server.addHook('onClose', async (instance) => {
+server.addHook('onClose', async function (instance) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
 })
 

package/test/types/route.test-d.ts

@@ -19,6 +19,13 @@ declare module '../../fastify' {
   interface FastifyContextConfig {
     foo: string;
     bar: number;
+    includeMessage?: boolean;
+  }
+
+  interface FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger, RequestType> {
+    message: ContextConfig extends { includeMessage: true }
+      ? string
+      : null;
   }
 }
 
@@ -36,6 +43,22 @@ const routeHandlerWithReturnValue: RouteHandlerMethod = function (request, reply
   return reply.send()
 }
 
+fastify().get(
+  '/',
+  { config: { foo: 'bar', bar: 100, includeMessage: true } },
+  (req) => {
+    expectType<string>(req.message)
+  }
+)
+
+fastify().get(
+  '/',
+  { config: { foo: 'bar', bar: 100, includeMessage: false } },
+  (req) => {
+    expectType<null>(req.message)
+  }
+)
+
 type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options';
 
 ['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'DELETE', 'OPTIONS'].forEach(method => {

package/test/types/schema.test-d.ts

@@ -20,6 +20,25 @@ expectAssignable<FastifyInstance>(server.get(
   () => { }
 ))
 
+expectAssignable<FastifyInstance>(server.post(
+  '/multiple-content-schema',
+  {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: { type: 'object' }
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  },
+  () => { }
+))
+
 expectAssignable<FastifyInstance>(server.get(
   '/empty-schema',
   {