fastify 2.7.1 → 2.11.0

package/test/route-hooks.test.js

@@ -3,15 +3,23 @@
 const test = require('tap').test
 const Fastify = require('../')
 
-function testHook (hook) {
+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)
@@ -29,22 +37,55 @@ function testHook (hook) {
   })
 
   test(`${hook} option should be called after ${hook} hook`, t => {
-    t.plan(2)
+    t.plan(3)
     const fastify = Fastify()
-    let check = ''
+    const checker = Object.defineProperty({ calledTimes: 0 }, 'check', {
+      get: function () { return ++this.calledTimes }
+    })
 
-    fastify.addHook(hook, (req, reply, next) => {
-      check = 'a'
-      next()
+    fastify.addHook(hook, (req, reply, nextOrPayload, next) => {
+      t.equal(checker.check, 1)
+      endMiddleware(nextOrPayload, next)
     })
 
     fastify.post('/', {
-      [hook]: (req, reply, done) => {
-        check += 'b'
-        done()
+      [hook]: (req, reply, nextOrPayload, next) => {
+        t.equal(checker.check, 2)
+        endMiddleware(nextOrPayload, next)
       }
     }, (req, reply) => {
-      reply.send({ check })
+      reply.send({})
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      payload: { hello: 'world' }
+    }, (err, res) => {
+      t.error(err)
+    })
+  })
+
+  test(`${hook} option could accept an array of functions`, t => {
+    t.plan(3)
+    const fastify = Fastify()
+    const checker = Object.defineProperty({ calledTimes: 0 }, 'check', {
+      get: function () { return ++this.calledTimes }
+    })
+
+    fastify.post('/', {
+      [hook]: [
+        (req, reply, nextOrPayload, next) => {
+          t.equal(checker.check, 1)
+          endMiddleware(nextOrPayload, next)
+        },
+        (req, reply, nextOrPayload, next) => {
+          t.equal(checker.check, 2)
+          endMiddleware(nextOrPayload, next)
+        }
+      ]
+    }, (req, reply) => {
+      reply.send({})
     })
 
     fastify.inject({
@@ -53,11 +94,55 @@ function testHook (hook) {
       payload: { hello: 'world' }
     }, (err, res) => {
       t.error(err)
-      var payload = JSON.parse(res.payload)
-      t.deepEqual(payload, { check: 'ab' })
     })
   })
 
+  test(`${hook} option does not interfere with ${hook} hook`, t => {
+    t.plan(7)
+    const fastify = Fastify()
+    const checker = Object.defineProperty({ calledTimes: 0 }, 'check', {
+      get: function () { return ++this.calledTimes }
+    })
+
+    fastify.addHook(hook, (req, reply, nextOrPayload, next) => {
+      t.equal(checker.check, 1)
+      endMiddleware(nextOrPayload, next)
+    })
+
+    fastify.post('/', {
+      [hook]: (req, reply, nextOrPayload, next) => {
+        t.equal(checker.check, 2)
+        endMiddleware(nextOrPayload, next)
+      }
+    }, handler)
+
+    fastify.post('/no', handler)
+
+    function handler (req, reply) {
+      reply.send({})
+    }
+
+    fastify.inject({
+      method: 'post',
+      url: '/'
+    }, (err, res) => {
+      t.error(err)
+      t.equal(checker.calledTimes, 2)
+
+      checker.calledTimes = 0
+
+      fastify.inject({
+        method: 'post',
+        url: '/no'
+      }, (err, res) => {
+        t.error(err)
+        t.equal(checker.calledTimes, 1)
+      })
+    })
+  })
+}
+
+function testBeforeHandlerHook (hook) {
   test(`${hook} option should be unique per route`, t => {
     t.plan(4)
     const fastify = Fastify()
@@ -153,79 +238,6 @@ function testHook (hook) {
     })
   })
 
-  test(`${hook} option could accept an array of functions`, t => {
-    t.plan(2)
-    const fastify = Fastify()
-
-    fastify.post('/', {
-      [hook]: [
-        (req, reply, done) => {
-          req.aa = 'a'
-          done()
-        },
-        (req, reply, done) => {
-          req.aa += 'b'
-          done()
-        }
-      ]
-    }, (req, reply) => {
-      reply.send({ aa: req.aa })
-    })
-
-    fastify.inject({
-      method: 'POST',
-      url: '/',
-      payload: { hello: 'world' }
-    }, (err, res) => {
-      t.error(err)
-      var payload = JSON.parse(res.payload)
-      t.deepEqual(payload, { aa: 'ab' })
-    })
-  })
-
-  test(`${hook} option does not interfere with ${hook} hook`, t => {
-    t.plan(4)
-    const fastify = Fastify()
-
-    fastify.addHook(hook, (req, reply, next) => {
-      req.check = 'a'
-      next()
-    })
-
-    fastify.post('/', {
-      [hook]: (req, reply, done) => {
-        req.check += 'b'
-        done()
-      }
-    }, handler)
-
-    fastify.post('/no', handler)
-
-    function handler (req, reply) {
-      reply.send({ check: req.check })
-    }
-
-    fastify.inject({
-      method: 'post',
-      url: '/',
-      payload: { hello: 'world' }
-    }, (err, res) => {
-      t.error(err)
-      var payload = JSON.parse(res.payload)
-      t.deepEqual(payload, { check: 'ab' })
-    })
-
-    fastify.inject({
-      method: 'post',
-      url: '/no',
-      payload: { hello: 'world' }
-    }, (err, res) => {
-      t.error(err)
-      var payload = JSON.parse(res.payload)
-      t.deepEqual(payload, { check: 'a' })
-    })
-  })
-
   test(`${hook} option should keep the context`, t => {
     t.plan(3)
     const fastify = Fastify()
@@ -281,11 +293,17 @@ function testHook (hook) {
   })
 }
 
+testExecutionHook('preHandler')
+testExecutionHook('onSend')
+testExecutionHook('onRequest')
+testExecutionHook('onResponse')
+testExecutionHook('preValidation')
+testExecutionHook('preParsing')
 // hooks that comes before the handler
-testHook('preHandler')
-testHook('onRequest')
-testHook('preValidation')
-testHook('preParsing')
+testBeforeHandlerHook('preHandler')
+testBeforeHandlerHook('onRequest')
+testBeforeHandlerHook('preValidation')
+testBeforeHandlerHook('preParsing')
 
 test('preHandler backwards compatibility with beforeHandler option (should emit a warning)', t => {
   t.plan(4)

package/test/route-prefix.test.js

@@ -484,7 +484,7 @@ test('returns 404 status code with /prefix/ and / route - prefixTrailingSlash: "
     t.error(err)
     t.same(JSON.parse(res.payload), {
       error: 'Not Found',
-      message: 'Not Found',
+      message: 'Route GET:/prefix// not found',
       statusCode: 404
     })
   })

package/test/schemas.test.js

@@ -0,0 +1,450 @@
+'use strict'
+
+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 })
+
+const schemaUsed = {
+  $id: 'urn:schema:foo',
+  definitions: {
+    foo: { type: 'string' }
+  },
+  type: 'object',
+  properties: {
+    foo: { $ref: '#/definitions/foo' }
+  }
+}
+const schemaParent = {
+  $id: 'urn:schema:response',
+  type: 'object',
+  required: ['foo'],
+  properties: {
+    foo: { $ref: 'urn:schema:foo#/definitions/foo' }
+  }
+}
+
+const schemaRequest = {
+  $id: 'urn:schema:request',
+  type: 'object',
+  required: ['foo'],
+  properties: {
+    foo: { $ref: 'urn:schema:response#/properties/foo' }
+  }
+}
+
+test('Should use the ref resolver - response', t => {
+  t.plan(2)
+  const fastify = Fastify()
+  const ajv = new AJV()
+  ajv.addSchema(fastClone(schemaParent))
+  ajv.addSchema(fastClone(schemaUsed))
+
+  fastify.setSchemaCompiler(schema => ajv.compile(schema))
+  fastify.setSchemaResolver((ref) => {
+    t.equals(ref, 'urn:schema:foo')
+    return ajv.getSchema(ref).schema
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    schema: {
+      response: {
+        '2xx': ajv.getSchema('urn:schema:response').schema
+      }
+    },
+    handler (req, reply) {
+      reply.send({ foo: 'bar' })
+    }
+  })
+
+  fastify.ready(t.error)
+})
+
+test('Should use the ref resolver - body', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  const ajv = new AJV()
+  ajv.addSchema(fastClone(schemaParent))
+  ajv.addSchema(fastClone(schemaUsed))
+
+  fastify.setSchemaCompiler(schema => ajv.compile(schema))
+  fastify.setSchemaResolver((ref) => {
+    t.equals(ref, 'urn:schema:foo')
+    return ajv.getSchema(ref).schema
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/',
+    schema: {
+      body: ajv.getSchema('urn:schema:response').schema
+    },
+    handler (req, reply) {
+      reply.send({ foo: 'bar' })
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { foo: 'bar' }
+  }, (err, res) => {
+    t.error(err)
+    t.deepEquals(JSON.parse(res.payload), { foo: 'bar' })
+  })
+})
+
+test('Encapsulation', t => {
+  t.plan(14)
+  const fastify = Fastify()
+  const ajv = new AJV()
+  ajv.addSchema(fastClone(schemaParent))
+  ajv.addSchema(fastClone(schemaUsed))
+
+  fastify.register((instance, opts, next) => {
+    instance.setSchemaCompiler(schema => ajv.compile(schema))
+    instance.setSchemaResolver((ref) => {
+      return ajv.getSchema(ref).schema
+    })
+    instance.route({
+      method: 'POST',
+      url: '/',
+      schema: {
+        body: ajv.getSchema('urn:schema:response').schema
+      },
+      handler (req, reply) {
+        reply.send({ foo: 'bar' })
+      }
+    })
+
+    instance.register((instance, opts, next) => {
+      instance.route({
+        method: 'POST',
+        url: '/two',
+        schema: {
+          body: ajv.getSchema('urn:schema:response').schema
+        },
+        handler (req, reply) {
+          reply.send({ foo: 'bar' })
+        }
+      })
+      next()
+    })
+    next()
+  })
+
+  fastify.register((instance, opts, next) => {
+    instance.route({
+      method: 'POST',
+      url: '/clean',
+      handler (req, reply) {
+        reply.send({ foo: 'bar' })
+      }
+    })
+    next()
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      payload: { foo: 'bar' }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+      t.deepEquals(JSON.parse(res.payload), { foo: 'bar' })
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      payload: { wrongFoo: 'bar' }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 400)
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/two',
+      payload: { foo: 'bar' }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+      t.deepEquals(JSON.parse(res.payload), { foo: 'bar' })
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/two',
+      payload: { wrongFoo: 'bar' }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 400)
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/clean',
+      payload: { wrongFoo: 'bar' }
+    }, (err, res) => {
+      t.error(err)
+      t.equals(res.statusCode, 200)
+      t.deepEquals(JSON.parse(res.payload), { foo: 'bar' })
+    })
+  })
+})
+
+test('Schema resolver without schema compiler', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.setSchemaResolver(() => { t.fail('the schema resolver will never be called') })
+  fastify.route({
+    method: 'POST',
+    url: '/',
+    schema: {},
+    handler (req, reply) {
+      reply.send({ foo: 'bar' })
+    }
+  })
+
+  fastify.ready(err => {
+    t.is(err.code, 'FST_ERR_SCH_MISSING_COMPILER')
+    t.isLike(err.message, /You must provide a schemaCompiler to route POST \/ to use the schemaResolver/)
+  })
+})
+
+test('Triple $ref deep', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const ajv = new AJV()
+  ajv.addSchema(fastClone(schemaParent))
+  ajv.addSchema(fastClone(schemaUsed))
+  ajv.addSchema(fastClone(schemaRequest))
+
+  fastify.setSchemaCompiler(schema => ajv.compile(schema))
+  fastify.setSchemaResolver((ref) => {
+    return ajv.getSchema(ref).schema
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/',
+    schema: {
+      body: ajv.getSchema('urn:schema:request').schema,
+      response: {
+        '2xx': ajv.getSchema('urn:schema:response').schema
+      }
+    },
+    handler (req, reply) {
+      reply.send({ foo: 'bar' })
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { foo: 'bar' }
+  }, (err, res) => {
+    t.error(err)
+    t.equals(res.statusCode, 200)
+    t.deepEquals(JSON.parse(res.payload), { foo: 'bar' })
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { fool: 'bar' }
+  }, (err, res) => {
+    t.error(err)
+    t.equals(res.statusCode, 400)
+    t.deepEquals(JSON.parse(res.payload).message, "body should have required property 'foo'")
+  })
+})
+
+test('$ref with a simple $id', t => {
+  t.plan(4)
+  const fastify = Fastify()
+  const ajv = new AJV()
+  ajv.addSchema(fastClone(schemaUsed))
+  ajv.addSchema({
+    $id: 'urn:schema:response',
+    type: 'object',
+    required: ['foo'],
+    properties: {
+      foo: { $ref: 'urn:schema:foo' }
+    }
+  })
+  ajv.addSchema({
+    $id: 'urn:schema:request',
+    type: 'object',
+    required: ['foo'],
+    properties: {
+      foo: { $ref: 'urn:schema:foo' }
+    }
+  })
+
+  fastify.setSchemaCompiler(schema => ajv.compile(schema))
+  fastify.setSchemaResolver((ref) => {
+    t.equals(ref, 'urn:schema:foo')
+    return ajv.getSchema(ref).schema
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/',
+    schema: {
+      body: ajv.getSchema('urn:schema:request').schema,
+      response: {
+        '2xx': ajv.getSchema('urn:schema:response').schema
+      }
+    },
+    handler (req, reply) {
+      reply.send({ foo: { foo: 'bar', bar: 'foo' } })
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: { foo: { foo: 'bar' } }
+  }, (err, res) => {
+    t.error(err)
+    t.equals(res.statusCode, 200)
+    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/shared-schemas.test.js

@@ -701,7 +701,7 @@ test('The schema resolver should clean the $id key before passing it to the comp
     url: '/',
     method: 'GET',
     schema: {
-      description: `get`,
+      description: 'get',
       body: 'second#',
       response: {
         200: 'second#'
@@ -716,7 +716,7 @@ test('The schema resolver should clean the $id key before passing it to the comp
     url: '/',
     method: 'PATCH',
     schema: {
-      description: `patch`,
+      description: 'patch',
       body: 'first#',
       response: {
         200: 'first#'