fastify 3.27.4 → 4.0.0-alpha.3

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

@@ -3,7 +3,7 @@ import fastify, { FastifyInstance, FastifyRequest, FastifySchema } from '../../f
 import { RouteGenericInterface } from '../../types/route'
 import { ContextConfigDefault } from '../../types/utils'
 import { FastifyReply } from '../../types/reply'
-import Ajv = require('ajv')
+import Ajv from 'ajv'
 
 const server = fastify()
 
@@ -35,33 +35,6 @@ expectAssignable<FastifyInstance>(server.get(
   () => { }
 ))
 
-expectAssignable<FastifyInstance>(server.get<RouteGenericInterface, ContextConfigDefault, { validate:(data: any) => any }>(
-  '/no-schema',
-{
-  schema: {},
-  validatorCompiler: ({ schema }) => {
-    // Error: Property 'validate' does not exist on type 'FastifySchema'.
-    return (data: any) => schema.validate(data)
-  }
-},
-() => { }
-))
-
-expectAssignable<FastifyInstance>(
-  server.route<RouteGenericInterface, ContextConfigDefault, { validate:(data: any) => any }>(
-    {
-      schema: {},
-      validatorCompiler: ({ schema }) => {
-        // Error: Property 'validate' does not exist on type 'FastifySchema'.
-        return (data: any) => schema.validate(data)
-      },
-      method: 'POST',
-      url: '/',
-      handler: async (_request: FastifyRequest, _reply: FastifyReply) => {}
-    }
-  )
-)
-
 expectAssignable<FastifyInstance>(server.setValidatorCompiler(({ schema }) => {
   return new Ajv().compile(schema)
 }))
@@ -83,20 +56,10 @@ expectAssignable<FastifyInstance>(server.post('/test', {
 
 expectAssignable<FastifyInstance>(server.setValidatorCompiler<FastifySchema & { validate: Record<string, unknown> }>(
   function ({ schema }) {
-    return new Ajv().compile(schema.validate)
+    return new Ajv().compile(schema)
   }
 ))
 
 expectAssignable<FastifyInstance>(server.setSerializerCompiler<FastifySchema & { validate: string }>(
   () => data => JSON.stringify(data)
 ))
-
-expectError(server.get(
-  '/unknown-schema-prop',
-  {
-    schema: {
-      unknown: { type: 'null' }
-    }
-  },
-  () => { }
-))

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

@@ -0,0 +1,424 @@
+import fastify, {
+  ContextConfigDefault, FastifySchema,
+  FastifyTypeProvider, RawReplyDefaultExpression,
+  RawRequestDefaultExpression,
+  RawServerDefault,
+  RouteHandlerMethod
+} 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'
+import { RouteGenericInterface } from '../../types/route'
+
+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): Promise<RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, TypeBoxProvider>> => {
+    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): Promise<RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, TypeBoxProvider>> => {
+    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',