fastify 2.10.0 → 2.11.0

package/test/logger.test.js

@@ -567,6 +567,40 @@ test('Should set a custom logLevel for a plugin', t => {
   })
 })
 
+test('Should set a custom logSerializers for a plugin', t => {
+  t.plan(3)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'XHello')
+    }
+  })
+
+  const logger = pino({ level: 'error' }, splitStream)
+
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/plugin', (req, reply) => {
+      req.log.info({ test: 'Hello' }) // we should see this log
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logLevel: 'info', logSerializers: { test: value => 'X' + value } })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/plugin'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
 test('Should set a custom logLevel for every plugin', t => {
   const lines = ['incoming request', 'request completed', 'info', 'debug']
   t.plan(18)
@@ -634,6 +668,281 @@ test('Should set a custom logLevel for every plugin', t => {
   })
 })
 
+test('Should set a custom logSerializers for every plugin', t => {
+  const lines = ['Hello', 'XHello', 'ZHello']
+  t.plan(9)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, lines.shift())
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.get('/', (req, reply) => {
+    req.log.warn({ test: 'Hello' })
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/test1', (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logSerializers: { test: value => 'X' + value } })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/test2', (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logSerializers: { test: value => 'Z' + value } })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/test1'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/test2'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should override serializers from route', t => {
+  t.plan(3)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'ZHello')
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.get('/', {
+      logSerializers: {
+        test: value => 'Z' + value // should override
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }, { logSerializers: { test: value => 'X' + value } })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should override serializers from plugin', t => {
+  t.plan(3)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'ZHello')
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.register(context1, {
+      logSerializers: {
+        test: value => 'Z' + value // should override
+      }
+    })
+    next()
+  }, { logSerializers: { test: value => 'X' + value } })
+
+  function context1 (instance, opts, next) {
+    instance.get('/', (req, reply) => {
+      req.log.info({ test: 'Hello' })
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should use serializers from plugin and route', t => {
+  t.plan(4)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'XHello')
+    }
+    if (line.test2) {
+      t.is(line.test2, 'ZHello')
+    }
+  })
+
+  const logger = pino({ level: 'info' }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.register(context1, {
+    logSerializers: { test: value => 'X' + value }
+  })
+
+  function context1 (instance, opts, next) {
+    instance.get('/', {
+      logSerializers: {
+        test2: value => 'Z' + value
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should use serializers from instance fastify and route', t => {
+  t.plan(4)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test) {
+      t.is(line.test, 'XHello')
+    }
+    if (line.test2) {
+      t.is(line.test2, 'ZHello')
+    }
+  })
+
+  const logger = pino({
+    level: 'info',
+    serializers: {
+      test: value => 'X' + value,
+      test2: value => 'This should be override - ' + value
+    }
+  }, splitStream)
+  const fastify = Fastify({
+    logger
+  })
+
+  fastify.get('/', {
+    logSerializers: {
+      test2: value => 'Z' + value
+    }
+  }, (req, reply) => {
+    req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
+test('Should use serializers inherit from contexts', t => {
+  t.plan(5)
+
+  const splitStream = split(JSON.parse)
+  splitStream.on('data', (line) => {
+    if (line.test && line.test2 && line.test3) {
+      t.is(line.test, 'XHello')
+      t.is(line.test2, 'YHello')
+      t.is(line.test3, 'ZHello')
+    }
+  })
+
+  const logger = pino({
+    level: 'info',
+    serializers: {
+      test: value => 'X' + value
+    }
+  }, splitStream)
+
+  const fastify = Fastify({ logger })
+  fastify.register(context1, { logSerializers: { test2: value => 'Y' + value } })
+
+  function context1 (instance, opts, next) {
+    instance.get('/', {
+      logSerializers: {
+        test3: value => 'Z' + value
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello', test2: 'Hello', test3: 'Hello' }) // { test: 'XHello', test2: 'YHello', test3: 'ZHello' }
+      reply.send({ hello: 'world' })
+    })
+    next()
+  }
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.deepEqual(payload, { hello: 'world' })
+  })
+})
+
 test('Should increase the log level for a specific plugin', t => {
   t.plan(4)
 

package/test/proto-poisoning.test.js

@@ -81,3 +81,79 @@ test('proto-poisoning ignore', t => {
     })
   })
 })
+
+test('constructor-poisoning ignore (default in v2)', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.post('/', (request, reply) => {
+    reply.send('ok')
+  })
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+    })
+  })
+})
+
+test('constructor-poisoning error', t => {
+  t.plan(3)
+
+  const fastify = Fastify({ onConstructorPoisoning: 'error' })
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.post('/', (request, reply) => {
+    t.fail('handler should not be called')
+  })
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 400)
+    })
+  })
+})
+
+test('constructor-poisoning remove', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ onProtoPoisoning: 'remove' })
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.post('/', (request, reply) => {
+    t.equal(undefined, Object.assign({}, request.body).foo)
+    reply.send({ ok: true })
+  })
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+    }, (err, response, body) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 200)
+    })
+  })
+})

package/test/route-hooks.test.js

@@ -3,15 +3,23 @@
 const test = require('tap').test
 const Fastify = require('../')
 
+function endMiddleware (nextOrPayload, next) {
+  if (typeof nextOrPayload === 'function') {
+    nextOrPayload()
+  } else {
+    next()
+  }
+}
+
 function testExecutionHook (hook) {
   test(`${hook}`, t => {
     t.plan(3)
     const fastify = Fastify()
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
+      [hook]: (req, reply, nextOrPayload, next) => {
         t.pass('hook called')
-        done()
+        endMiddleware(nextOrPayload, next)
       }
     }, (req, reply) => {
       reply.send(req.body)
@@ -35,15 +43,15 @@ function testExecutionHook (hook) {
       get: function () { return ++this.calledTimes }
     })
 
-    fastify.addHook(hook, (req, reply, next) => {
+    fastify.addHook(hook, (req, reply, nextOrPayload, next) => {
       t.equal(checker.check, 1)
-      next()
+      endMiddleware(nextOrPayload, next)
     })
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
+      [hook]: (req, reply, nextOrPayload, next) => {
         t.equal(checker.check, 2)
-        done()
+        endMiddleware(nextOrPayload, next)
       }
     }, (req, reply) => {
       reply.send({})
@@ -67,13 +75,13 @@ function testExecutionHook (hook) {
 
     fastify.post('/', {
       [hook]: [
-        (req, reply, done) => {
+        (req, reply, nextOrPayload, next) => {
           t.equal(checker.check, 1)
-          done()
+          endMiddleware(nextOrPayload, next)
         },
-        (req, reply, done) => {
+        (req, reply, nextOrPayload, next) => {
           t.equal(checker.check, 2)
-          done()
+          endMiddleware(nextOrPayload, next)
         }
       ]
     }, (req, reply) => {
@@ -96,15 +104,15 @@ function testExecutionHook (hook) {
       get: function () { return ++this.calledTimes }
     })
 
-    fastify.addHook(hook, (req, reply, next) => {
+    fastify.addHook(hook, (req, reply, nextOrPayload, next) => {
       t.equal(checker.check, 1)
-      next()
+      endMiddleware(nextOrPayload, next)
     })
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
+      [hook]: (req, reply, nextOrPayload, next) => {
         t.equal(checker.check, 2)
-        done()
+        endMiddleware(nextOrPayload, next)
       }
     }, handler)
 
@@ -286,6 +294,7 @@ function testBeforeHandlerHook (hook) {
 }
 
 testExecutionHook('preHandler')
+testExecutionHook('onSend')
 testExecutionHook('onRequest')
 testExecutionHook('onResponse')
 testExecutionHook('preValidation')

package/test/schemas.test.js

@@ -4,6 +4,7 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 
+const ajvMergePatch = require('ajv-merge-patch')
 const AJV = require('ajv')
 const fastClone = require('rfdc')({ circles: false, proto: true })
 
@@ -322,3 +323,128 @@ test('$ref with a simple $id', t => {
     t.deepEquals(JSON.parse(res.payload), { foo: { foo: 'bar' } })
   })
 })
+
+test('Should handle root $merge keywords in header', t => {
+  t.plan(5)
+  const fastify = Fastify({
+    ajv: {
+      plugins: [
+        ajvMergePatch
+      ]
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    schema: {
+      headers: {
+        $merge: {
+          source: {
+            type: 'object',
+            properties: {
+              q: {
+                type: 'string'
+              }
+            }
+          },
+          with: {
+            required: ['q']
+          }
+        }
+      }
+    },
+    handler (req, reply) {
+      reply.send({ ok: 1 })
+    }
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'GET',
+      url: '/'
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 400)
+    })
+
+    fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: {
+        q: 'foo'
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+    })
+  })
+})
+
+test('Should handle root $patch keywords in header', t => {
+  t.plan(5)
+  const fastify = Fastify({
+    ajv: {
+      plugins: [
+        ajvMergePatch
+      ]
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    schema: {
+      headers: {
+        $patch: {
+          source: {
+            type: 'object',
+            properties: {
+              q: {
+                type: 'string'
+              }
+            }
+          },
+          with: [
+            {
+              op: 'add',
+              path: '/properties/q',
+              value: { type: 'number' }
+            }
+          ]
+        }
+      }
+    },
+    handler (req, reply) {
+      reply.send({ ok: 1 })
+    }
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: {
+        q: 'foo'
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 400)
+    })
+
+    fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: {
+        q: 10
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+    })
+  })
+})

package/test/types/index.ts

@@ -64,7 +64,31 @@ const cors = require('cors')
     maxParamLength: 200,
     querystringParser: (str: string) => ({ str: str, strArray: [str] }),
     modifyCoreObjects: true,
-    return503OnClosing: true
+    return503OnClosing: true,
+    genReqId: () => {
+      if (Math.random() > 0.5) {
+        return Math.random().toString()
+      }
+      return Math.random()
+    },
+    requestIdHeader: 'request-id',
+    requestIdLogLabel: 'reqId',
+    serverFactory: (handler, options) => {
+      const server = http.createServer((req, res) => {
+        handler(req, res)
+      })
+      return server
+    }
+  })
+
+  // http2 server factory option
+  const otherHttp2Server = fastify({
+    serverFactory: (handler, options) => {
+      const server = http2.createServer((req, res) => {
+        handler(req, res)
+      })
+      return server
+    }
   })
 
   // custom types
@@ -102,6 +126,11 @@ server.use('/', (req, res, next) => {
   console.log(`${req.method} ${req.url}`)
 })
 
+// Custom middleware with multiple paths
+server.use(['/foo', '/bar'], (req, res, next) => {
+  console.log(`${req.method} ${req.url}`)
+})
+
 // Third party plugin
 // Also check if async functions are allowed to be passed to .register()
 // https://github.com/fastify/fastify/pull/1841
@@ -233,6 +262,7 @@ const opts: fastify.RouteShorthandOptions<http2.Http2SecureServer, http2.Http2Se
   schemaCompiler: (schema: Object) => () => {},
   bodyLimit: 5000,
   logLevel: 'trace',
+  version: '1.0.0',
   config: { }
 }
 const optsWithHandler: fastify.RouteShorthandOptions<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> = {