fastify 4.0.0-alpha.2 → 4.0.0-alpha.3

package/test/internals/reply.test.js

@@ -68,6 +68,7 @@ test('reply.send will logStream error and destroy the stream', t => {
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
+    write: () => {},
     headersSent: true
   })
 
@@ -89,6 +90,7 @@ test('reply.send throw with circular JSON', t => {
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
+    write: () => {},
     end: () => {}
   }
   const reply = new Reply(response, { context: { onSend: [] } })
@@ -106,6 +108,7 @@ test('reply.send returns itself', t => {
     hasHeader: () => false,
     getHeader: () => undefined,
     writeHead: () => {},
+    write: () => {},
     end: () => {}
   }
   const reply = new Reply(response, { context: { onSend: [] } })
@@ -264,7 +267,7 @@ test('within an instance', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     test('custom serializer should be used', t => {
       t.plan(3)
@@ -424,7 +427,7 @@ test('buffer without content type should send a application/octet-stream and raw
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -449,7 +452,7 @@ test('buffer with content type should not send application/octet-stream', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -477,7 +480,7 @@ test('stream with content type should not send application/octet-stream', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
@@ -503,7 +506,7 @@ test('stream without content type should not send application/octet-stream', t =
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
@@ -538,7 +541,7 @@ test('stream using reply.raw.writeHead should return customize headers', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
@@ -562,7 +565,7 @@ test('plain string without content type should send a text/plain', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -586,7 +589,7 @@ test('plain string with content type should be sent unmodified', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -613,7 +616,7 @@ test('plain string with content type and custom serializer should be serialized'
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -637,7 +640,7 @@ test('plain string with content type application/json should NOT be serialized a
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -690,7 +693,7 @@ test('plain string with custom json content type should NOT be serialized as jso
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     Object.keys(customSamples).forEach((path) => {
       sget({
@@ -716,7 +719,7 @@ test('non-string with content type application/json SHOULD be serialized as json
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -729,6 +732,30 @@ test('non-string with content type application/json SHOULD be serialized as json
   })
 })
 
+test('non-string with custom json\'s content-type SHOULD be serialized as json', t => {
+  t.plan(4)
+
+  const fastify = require('../..')()
+
+  fastify.get('/', function (req, reply) {
+    reply.type('application/json; version=2; ').send({ key: 'hello world!' })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    t.teardown(fastify.close.bind(fastify))
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.headers['content-type'], 'application/json; version=2; charset=utf-8')
+      t.same(body.toString(), JSON.stringify({ key: 'hello world!' }))
+    })
+  })
+})
+
 test('non-string with custom json content type SHOULD be serialized as json', t => {
   t.plan(16)
 
@@ -765,7 +792,7 @@ test('non-string with custom json content type SHOULD be serialized as json', t
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     Object.keys(customSamples).forEach((path) => {
       sget({
@@ -830,7 +857,7 @@ test('undefined payload should be sent as-is', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -875,7 +902,7 @@ test('for HEAD method, no body should be sent but content-length should be', t =
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'HEAD',
@@ -923,7 +950,7 @@ test('reply.send(new NotFound()) should not invoke the 404 handler', t => {
   fastify.listen({ port: 0 }, err => {
     t.error(err)
 
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -969,7 +996,7 @@ test('reply can set multiple instances of same header', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',
@@ -996,7 +1023,7 @@ test('reply.hasHeader returns correct values', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
@@ -1025,7 +1052,7 @@ test('reply.getHeader returns correct values', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
@@ -1095,7 +1122,7 @@ test('reply.removeHeader can remove the value', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
@@ -1122,7 +1149,7 @@ test('reply.header can reset the value', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
@@ -1151,7 +1178,7 @@ test('reply.hasHeader computes raw and fastify headers', t => {
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
@@ -1320,7 +1347,7 @@ test('reply.header setting multiple cookies as multiple Set-Cookie headers', t =
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
-    fastify.server.unref()
+    t.teardown(fastify.close.bind(fastify))
 
     sget({
       method: 'GET',

package/test/listen.test.js

@@ -35,6 +35,33 @@ test('listen works without arguments', async t => {
   t.ok(address.port > 0)
 })
 
+test('Async/await listen with arguments', async t => {
+  process.on('warning', () => {
+    t.fail('should not be deprecated')
+  })
+
+  t.plan(1)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
+  const address = fastify.server.address()
+  t.equal(addr, `http://${address.address}:${address.port}`)
+})
+
+test('Promise listen with arguments', t => {
+  process.on('warning', () => {
+    t.fail('should not be deprecated')
+  })
+
+  t.plan(1)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  fastify.listen({ port: 0, host: '0.0.0.0' }).then(addr => {
+    const address = fastify.server.address()
+    t.equal(addr, `http://${address.address}:${address.port}`)
+  })
+})
+
 test('listen accepts a callback', t => {
   process.on('warning', () => {
     t.fail('should not be deprecated')

package/test/reply-trailers.test.js

@@ -0,0 +1,270 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const { Readable } = require('stream')
+const { createHash } = require('crypto')
+
+test('send trailers when payload is empty string', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('send trailers when payload is empty buffer', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send(Buffer.alloc(0))
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('send trailers when payload is undefined', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('send trailers when payload is json', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const data = JSON.stringify({ hello: 'world' })
+  const hash = createHash('md5')
+  hash.update(data)
+  const md5 = hash.digest('hex')
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('Content-MD5', function (reply, payload) {
+      t.equal(data, payload)
+      const hash = createHash('md5')
+      hash.update(payload)
+      return hash.digest('hex')
+    })
+    reply.send(data)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.equal(res.headers.trailer, 'content-md5')
+    t.equal(res.trailers['content-md5'], md5)
+  })
+})
+
+test('send trailers when payload is stream', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      t.same(payload, null)
+      return 'custom-etag'
+    })
+    const stream = Readable.from([JSON.stringify({ hello: 'world' })])
+    reply.send(stream)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+  })
+})
+
+test('removeTrailer', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.removeTrailer('ETag') // remove nothing
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.trailer('Should-Not-Call', function (reply, payload) {
+      t.fail('it should not called as this trailer is removed')
+      return 'should-not-call'
+    })
+    reply.removeTrailer('Should-Not-Call')
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notOk(res.trailers['should-not-call'])
+  })
+})
+
+test('hasTrailer', t => {
+  t.plan(9)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    t.equal(reply.hasTrailer('ETag'), false)
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    t.equal(reply.hasTrailer('ETag'), true)
+    reply.trailer('Should-Not-Call', function (reply, payload) {
+      t.fail('it should not called as this trailer is removed')
+      return 'should-not-call'
+    })
+    t.equal(reply.hasTrailer('Should-Not-Call'), true)
+    reply.removeTrailer('Should-Not-Call')
+    t.equal(reply.hasTrailer('Should-Not-Call'), false)
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notOk(res.trailers['should-not-call'])
+  })
+})
+
+test('throw error when trailer header name is not allowed', t => {
+  const INVALID_TRAILERS = [
+    'transfer-encoding',
+    'content-length',
+    'host',
+    'cache-control',
+    'max-forwards',
+    'te',
+    'authorization',
+    'set-cookie',
+    'content-encoding',
+    'content-type',
+    'content-range',
+    'trailer'
+  ]
+  t.plan(INVALID_TRAILERS.length + 2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    for (const key of INVALID_TRAILERS) {
+      try {
+        reply.trailer(key, () => {})
+      } catch (err) {
+        t.equal(err.message, `Called reply.trailer with an invalid header name: ${key}`)
+      }
+    }
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('throw error when trailer header value is not function', t => {
+  const INVALID_TRAILERS_VALUE = [
+    undefined,
+    null,
+    true,
+    false,
+    'invalid',
+    [],
+    new Date(),
+    {}
+  ]
+  t.plan(INVALID_TRAILERS_VALUE.length + 2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    for (const value of INVALID_TRAILERS_VALUE) {
+      try {
+        reply.trailer('invalid', value)
+      } catch (err) {
+        t.equal(err.message, `Called reply.trailer('invalid', fn) with an invalid type: ${typeof value}. Expected a function.`)
+      }
+    }
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})

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

@@ -6,12 +6,16 @@ import fastify, {
   FastifyRequest,
   RawReplyDefaultExpression,
   RawRequestDefaultExpression,
-  RawServerBase,
   RouteOptions,
   RegisterOptions,
-  FastifyPluginOptions
+  FastifyPluginOptions,
+  FastifySchema,
+  FastifyTypeProviderDefault,
+  ContextConfigDefault, FastifyContextConfig, RawServerDefault
 } from '../../fastify'
 import { preHandlerAsyncHookHandler, RequestPayload } from '../../types/hooks'
+import { RouteGenericInterface } from '../../types/route'
+import { ResolveFastifyRequestType } from '../../types/type-provider'
 
 const server = fastify()
 
@@ -213,11 +217,15 @@ server.addHook('onClose', async (instance) => {
 // Use case to monitor any regression on issue #3620
 // ref.: https://github.com/fastify/fastify/issues/3620
 const customTypedHook: preHandlerAsyncHookHandler<
-RawServerBase,
+RawServerDefault,
 RawRequestDefaultExpression,
 RawReplyDefaultExpression,
-Record<string, unknown>
-> = async function (request, reply) {
+RouteGenericInterface,
+ContextConfigDefault,
+FastifySchema,
+FastifyTypeProviderDefault,
+ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>
+> = async function (request, reply): Promise<void> {
   expectType<FastifyInstance>(this)
   expectAssignable<FastifyRequest>(request)
   expectAssignable<FastifyReply>(reply)
@@ -226,3 +234,51 @@ Record<string, unknown>
 server.register(async (instance) => {
   instance.addHook('preHandler', customTypedHook)
 })
+
+// Test custom Context Config types for hooks
+type CustomContextConfig = FastifyContextConfig & {
+  foo: string;
+  bar: number;
+}
+
+server.route<RouteGenericInterface, CustomContextConfig>({
+  method: 'GET',
+  url: '/',
+  handler: () => {},
+  onRequest: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preParsing: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preValidation: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preHandler: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preSerialization: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onSend: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onResponse: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onTimeout: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onError: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  }
+})