fastify 3.27.3 → 4.0.0-alpha.2

package/test/types/type-provider.test-d.ts

@@ -0,0 +1,417 @@
+import fastify, { FastifyTypeProvider } from '../../fastify'
+import { expectAssignable, expectError, expectType } from 'tsd'
+import { IncomingHttpHeaders } from 'http'
+import { Type, TSchema, Static } from '@sinclair/typebox'
+import { FromSchema, JSONSchema } from 'json-schema-to-ts'
+
+const server = fastify()
+
+// -------------------------------------------------------------------
+// Remapping
+// -------------------------------------------------------------------
+
+interface NumberProvider extends FastifyTypeProvider { output: number } // remap all schemas to numbers
+
+expectAssignable(server.withTypeProvider<NumberProvider>().get(
+  '/',
+  {
+    schema: {
+      body: { type: 'string' },
+      querystring: { type: 'string' },
+      headers: { type: 'string' },
+      params: { type: 'string' }
+    }
+  },
+  (req) => {
+    expectType<number & IncomingHttpHeaders>(req.headers)
+    expectType<number>(req.body)
+    expectType<number>(req.query)
+    expectType<number>(req.params)
+  }
+))
+
+// -------------------------------------------------------------------
+// Override
+// -------------------------------------------------------------------
+
+interface OverriddenProvider extends FastifyTypeProvider { output: 'inferenced' }
+
+expectAssignable(server.withTypeProvider<OverriddenProvider>().get<{ Body: 'override' }>(
+  '/',
+  {
+    schema: {
+      body: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number()
+      })
+    }
+  },
+  (req) => {
+    expectType<'override'>(req.body)
+  }
+))
+
+// -------------------------------------------------------------------
+// TypeBox
+// -------------------------------------------------------------------
+
+interface TypeBoxProvider extends FastifyTypeProvider { output: this['input'] extends TSchema ? Static<this['input']> : never }
+
+expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
+  '/',
+  {
+    schema: {
+      body: Type.Object({
+        x: Type.Number(),
+        y: Type.Number(),
+        z: Type.Number()
+      })
+    }
+  },
+  (req) => {
+    expectType<number>(req.body.x)
+    expectType<number>(req.body.y)
+    expectType<number>(req.body.z)
+  }
+))
+
+// -------------------------------------------------------------------
+// JsonSchemaToTs
+// -------------------------------------------------------------------
+
+interface JsonSchemaToTsProvider extends FastifyTypeProvider { output: this['input'] extends JSONSchema ? FromSchema<this['input']> : never }
+
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          x: { type: 'number' },
+          y: { type: 'string' },
+          z: { type: 'boolean' }
+        }
+      } as const
+    }
+  },
+  (req) => {
+    expectType<number | undefined>(req.body.x)
+    expectType<string | undefined>(req.body.y)
+    expectType<boolean | undefined>(req.body.z)
+  }
+))
+
+// -------------------------------------------------------------------
+// Instance Type Remappable
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<TypeBoxProvider>().withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      body: {
+        type: 'object',
+        properties: {
+          x: { type: 'number' },
+          y: { type: 'string' },
+          z: { type: 'boolean' }
+        }
+      } as const
+    }
+  },
+  (req) => {
+    expectType<number | undefined>(req.body.x)
+    expectType<string | undefined>(req.body.y)
+    expectType<boolean | undefined>(req.body.z)
+  }
+))
+
+// -------------------------------------------------------------------
+// Request Hooks
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
+  '/',
+  {
+    schema: {
+      body: Type.Object({
+        x: Type.Number(),
+        y: Type.String(),
+        z: Type.Boolean()
+      })
+    },
+    preHandler: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    preParsing: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    preSerialization: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    preValidation: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    onError: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    onRequest: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    onResponse: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    onTimeout: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    },
+    onSend: req => {
+      expectType<number>(req.body.x)
+      expectType<string>(req.body.y)
+      expectType<boolean>(req.body.z)
+    }
+  },
+  req => {
+    expectType<number>(req.body.x)
+    expectType<string>(req.body.y)
+    expectType<boolean>(req.body.z)
+  }
+))
+
+// -------------------------------------------------------------------
+// TypeBox Reply Type
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: Type.String(),
+        400: Type.Number(),
+        500: Type.Object({
+          error: Type.String()
+        })
+      }
+    }
+  },
+  async (_, res) => {
+    res.send('hello')
+    res.send(42)
+    res.send({ error: 'error' })
+  }
+))
+
+// -------------------------------------------------------------------
+// TypeBox Reply Type: Non Assignable
+// -------------------------------------------------------------------
+
+expectError(server.withTypeProvider<TypeBoxProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: Type.String(),
+        400: Type.Number(),
+        500: Type.Object({
+          error: Type.String()
+        })
+      }
+    }
+  },
+  async (_, res) => {
+    res.send(false)
+  }
+))
+
+// -------------------------------------------------------------------
+// TypeBox Reply Return Type
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: Type.String(),
+        400: Type.Number(),
+        500: Type.Object({
+          error: Type.String()
+        })
+      }
+    }
+  },
+  async (_, res) => {
+    const option = 1 as 1 | 2 | 3
+    switch (option) {
+      case 1: return 'hello'
+      case 2: return 42
+      case 3: return { error: 'error' }
+    }
+  }
+))
+
+// -------------------------------------------------------------------
+// TypeBox Reply Return Type: Non Assignable
+// -------------------------------------------------------------------
+
+expectError(server.withTypeProvider<TypeBoxProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: Type.String(),
+        400: Type.Number(),
+        500: Type.Object({
+          error: Type.String()
+        })
+      }
+    }
+  },
+  async (_, res) => {
+    return false
+  }
+))
+
+// -------------------------------------------------------------------
+// JsonSchemaToTs Reply Type
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: { type: 'string' },
+        400: { type: 'number' },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  (_, res) => {
+    res.send('hello')
+    res.send(42)
+    res.send({ error: 'error' })
+  }
+))
+
+// -------------------------------------------------------------------
+// JsonSchemaToTs Reply Type: Non Assignable
+// -------------------------------------------------------------------
+
+expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: { type: 'string' },
+        400: { type: 'number' },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  async (_, res) => {
+    res.send(false)
+  }
+))
+
+// -------------------------------------------------------------------
+// JsonSchemaToTs Reply Type Return
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: { type: 'string' },
+        400: { type: 'number' },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  async (_, res) => {
+    const option = 1 as 1 | 2 | 3
+    switch (option) {
+      case 1: return 'hello'
+      case 2: return 42
+      case 3: return { error: 'error' }
+    }
+  }
+))
+// -------------------------------------------------------------------
+// JsonSchemaToTs Reply Type Return: Non Assignable
+// -------------------------------------------------------------------
+
+expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: { type: 'string' },
+        400: { type: 'number' },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  async (_, res) => {
+    return false
+  }
+))
+
+// -------------------------------------------------------------------
+// Reply Type Override
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+  '/',
+  {
+    schema: {
+      response: {
+        200: { type: 'string' },
+        400: { type: 'number' },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  async (_, res) => {
+    res.send(true)
+  }
+))
+
+// -------------------------------------------------------------------
+// Reply Type Return Override
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+  '/',
+  {
+    schema: {
+      response: {
+        200: { type: 'string' },
+        400: { type: 'number' },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  async (_, res) => {
+    return true
+  }
+))

package/test/url-rewriting.test.js

@@ -22,7 +22,7 @@ test('Should rewrite url', t => {
     }
   })
 
-  fastify.listen(0, function (err) {
+  fastify.listen({ port: 0 }, function (err) {
     t.error(err)
 
     sget({
@@ -55,7 +55,7 @@ test('Should not rewrite if the url is the same', t => {
     }
   })
 
-  fastify.listen(0, function (err) {
+  fastify.listen({ port: 0 }, function (err) {
     t.error(err)
 
     sget({
@@ -86,7 +86,7 @@ test('Should throw an error', t => {
     }
   })
 
-  fastify.listen(0, function (err) {
+  fastify.listen({ port: 0 }, function (err) {
     t.error(err)
 
     sget({

package/test/validation-error-handling.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('tap')
-const Joi = require('@hapi/joi')
+const Joi = require('joi')
 const Fastify = require('..')
 
 const schema = {
@@ -58,7 +58,7 @@ test('should fail immediately with invalid payload', t => {
     t.same(res.json(), {
       statusCode: 400,
       error: 'Bad Request',
-      message: "body should have required property 'name'"
+      message: "body must have required property 'name'"
     })
     t.equal(res.statusCode, 400)
   })
@@ -183,10 +183,10 @@ test('should be able to attach validation to request', t => {
 
     t.same(res.json(), [{
       keyword: 'required',
-      dataPath: '',
+      instancePath: '',
       schemaPath: '#/required',
       params: { missingProperty: 'name' },
-      message: 'should have required property \'name\''
+      message: 'must have required property \'name\''
     }])
     t.equal(res.statusCode, 400)
   })
@@ -213,7 +213,7 @@ test('should respect when attachValidation is explicitly set to false', t => {
     t.same(JSON.parse(res.payload), {
       statusCode: 400,
       error: 'Bad Request',
-      message: "body should have required property 'name'"
+      message: "body must have required property 'name'"
     })
     t.equal(res.statusCode, 400)
   })
@@ -243,7 +243,7 @@ test('Attached validation error should take precedence over setErrorHandler', t
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.same(res.payload, "Attached: Error: body should have required property 'name'")
+    t.same(res.payload, "Attached: Error: body must have required property 'name'")
     t.equal(res.statusCode, 400)
   })
 })
@@ -336,7 +336,7 @@ test('should return a defined output message parsing AJV errors', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.equal(res.payload, '{"statusCode":400,"error":"Bad Request","message":"body should have required property \'name\'"}')
+    t.equal(res.payload, '{"statusCode":400,"error":"Bad Request","message":"body must have required property \'name\'"}')
   })
 })
 
@@ -467,7 +467,7 @@ test('should call custom error formatter', t => {
   const fastify = Fastify({
     schemaErrorFormatter: (errors, dataVar) => {
       t.equal(errors.length, 1)
-      t.equal(errors[0].message, "should have required property 'name'")
+      t.equal(errors[0].message, "must have required property 'name'")
       t.equal(dataVar, 'body')
       return new Error('my error')
     }

package/test/versioned-routes.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test, before } = require('tap')
+const helper = require('./helper')
 const Fastify = require('..')
 const sget = require('simple-get').concat
 const http = require('http')
@@ -9,6 +9,13 @@ const split = require('split2')
 const append = require('vary').append
 const proxyquire = require('proxyquire')
 
+process.removeAllListeners('warning')
+
+let localhost
+before(async function () {
+  [localhost] = await helper.getLoopbackHost()
+})
+
 test('Should register a versioned route', t => {
   t.plan(11)
   const fastify = Fastify()
@@ -235,7 +242,7 @@ test('Should register a versioned route', t => {
     }
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -400,7 +407,7 @@ test('Bas accept version (server)', t => {
     }
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.server.unref()
 
@@ -442,12 +449,12 @@ test('test log stream', t => {
     reply.send(new Error('kaboom'))
   })
 
-  fastify.listen(0, err => {
+  fastify.listen({ port: 0, host: localhost }, err => {
     t.error(err)
     fastify.server.unref()
 
     http.get({
-      hostname: 'localhost',
+      hostname: fastify.server.address().hostname,
       port: fastify.server.address().port,
       path: '/',
       method: 'GET',
@@ -549,7 +556,7 @@ test('Should register a versioned route with custom versioning strategy', t => {
 })
 
 test('Should get error using an invalid a versioned route, using default validation (deprecated versioning option)', t => {
-  t.plan(1)
+  t.plan(3)
 
   const fastify = Fastify({
     versioning: {
@@ -577,15 +584,19 @@ test('Should get error using an invalid a versioned route, using default validat
     }
   })
 
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    // not a string version
-    constraints: { version: 2 },
-    handler: (req, reply) => {
-      reply.send({ hello: 'cant match route v2' })
-    }
-  })
+  try {
+    fastify.route({
+      method: 'GET',
+      url: '/',
+      // not a string version
+      constraints: { version: 2 },
+      handler: (req, reply) => {
+        reply.send({ hello: 'cant match route v2' })
+      }
+    })
+  } catch (err) {
+    t.equal(err.message, 'Version constraint should be a string.')
+  }
 
   fastify.inject({
     method: 'GET',
@@ -594,7 +605,8 @@ test('Should get error using an invalid a versioned route, using default validat
       Accept: 'application/vnd.example.api+json;version=2'
     }
   }, (err, res) => {
-    t.equal(err.message, 'Version constraint should be a string.')
+    t.error(err)
+    t.equal(res.statusCode, 404)
   })
 })
 
@@ -663,7 +675,7 @@ test('Should trigger a warning when a versioned route is registered via version
   }
 
   const route = proxyquire('../lib/route', { './warnings': warning })
-  const fastify = proxyquire('..', { './lib/route.js': route })()
+  const fastify = proxyquire('..', { './lib/route.js': route })({ exposeHeadRoutes: false })
 
   fastify.route({
     method: 'GET',

package/test/wrapThenable.test.js

@@ -2,21 +2,22 @@
 
 const t = require('tap')
 const test = t.test
-const { kReplySentOverwritten } = require('../lib/symbols')
+const { kReplyHijacked } = require('../lib/symbols')
 const wrapThenable = require('../lib/wrapThenable')
+const Reply = require('../lib/reply')
 
-test('should resolve immediately when reply[kReplySentOverwritten] is true', t => {
+test('should resolve immediately when reply[kReplyHijacked] is true', t => {
   const reply = {}
-  reply[kReplySentOverwritten] = true
+  reply[kReplyHijacked] = true
   const thenable = Promise.resolve()
   wrapThenable(thenable, reply)
   t.end()
 })
 
-test('should reject immediately when reply[kReplySentOverwritten] is true', t => {
+test('should reject immediately when reply[kReplyHijacked] is true', t => {
   t.plan(1)
-  const reply = { res: {} }
-  reply[kReplySentOverwritten] = true
+  const reply = new Reply({}, {}, {})
+  reply[kReplyHijacked] = true
   reply.log = {
     error: ({ err }) => {
       t.equal(err.message, 'Reply sent already')