fastify 3.27.3 → 4.0.0-alpha.2

package/test/type-provider.test.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+
+test('Should export withTypeProvider function', t => {
+  t.plan(1)
+  try {
+    Fastify().withTypeProvider()
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('Should return same instance', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.equal(fastify, fastify.withTypeProvider())
+})

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

@@ -7,7 +7,7 @@ import fastify, {
   LightMyRequestChain,
   LightMyRequestResponse,
   LightMyRequestCallback,
-  InjectOptions
+  InjectOptions, FastifyBaseLogger
 } from '../../fastify'
 import * as http from 'http'
 import * as https from 'https'
@@ -50,7 +50,9 @@ expectAssignable<InjectOptions>({ query: '' })
 fastify({ http2: true, https: {} }).inject().then((resp) => {
   expectAssignable<LightMyRequestResponse>(resp)
 })
-const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {}
+const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {
+  if (err) throw err
+}
 fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
 
 // server options
@@ -70,9 +72,9 @@ expectAssignable<FastifyInstance>(fastify({ serializerOpts: { rounding: 'ceil' }
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { ajv: { missingRefs: 'ignore' } } }))
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { schema: { } } }))
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { otherProp: { } } }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: true }))
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: true }))
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({
   logger: {
     level: 'info',
     genReqId: () => 'request-id',
@@ -103,6 +105,7 @@ expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerR
   }
 }))
 const customLogger = {
+  level: 'info',
   info: () => { },
   warn: () => { },
   error: () => { },
@@ -111,7 +114,7 @@ const customLogger = {
   debug: () => { },
   child: () => customLogger
 }
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({ logger: customLogger }))
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: customLogger }))
 expectAssignable<FastifyInstance>(fastify({ serverFactory: () => http.createServer() }))
 expectAssignable<FastifyInstance>(fastify({ caseSensitive: true }))
 expectAssignable<FastifyInstance>(fastify({ requestIdHeader: 'request-id' }))
@@ -174,24 +177,13 @@ expectAssignable<FastifyInstance>(fastify({ return503OnClosing: true }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
     customOptions: {
-      nullable: false
+      removeAdditional: 'all'
     },
     plugins: [() => { }]
   }
 }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
-    customOptions: {
-      nullable: false
-    },
-    plugins: [[() => { }, 'keyword']]
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  ajv: {
-    customOptions: {
-      nullable: false
-    },
     plugins: [[() => { }, ['keyword1', 'keyword2']]]
   }
 }))

package/test/types/import.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

package/test/types/import.ts

@@ -0,0 +1 @@
+import { FastifyLogFn } from '../../fastify'

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

@@ -1,3 +1,4 @@
+import { expectAssignable, expectDeprecated, expectError, expectNotDeprecated, expectType } from 'tsd'
 import fastify, {
   FastifyBodyParser,
   FastifyError,
@@ -6,10 +7,9 @@ import fastify, {
   RawRequestDefaultExpression,
   RawServerDefault
 } from '../../fastify'
-import { expectAssignable, expectError, expectType } from 'tsd'
-import { FastifyRequest } from '../../types/request'
-import { FastifyReply } from '../../types/reply'
 import { HookHandlerDoneFunction } from '../../types/hooks'
+import { FastifyReply } from '../../types/reply'
+import { FastifyRequest } from '../../types/request'
 import { FastifySchemaControllerOptions } from '../../types/schema'
 
 const server = fastify()
@@ -31,6 +31,7 @@ expectType<string>(server.printPlugins())
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
+    expectType<FastifyError>(error)
     expectAssignable<FastifyInstance>(this)
   })
 )
@@ -47,10 +48,14 @@ server.setErrorHandler(fastifyErrorHandler)
 async function asyncFastifyErrorHandler (this: FastifyInstance, error: FastifyError) {}
 server.setErrorHandler(asyncFastifyErrorHandler)
 
-function nodeJSErrorHandler (error: NodeJS.ErrnoException) {}
+function nodeJSErrorHandler (error: NodeJS.ErrnoException) {
+  if (error) { throw error }
+}
 server.setErrorHandler(nodeJSErrorHandler)
 
-function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {}
+function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {
+  if (error) { throw error }
+}
 server.setErrorHandler(asyncNodeJSErrorHandler)
 
 class CustomError extends Error {
@@ -82,20 +87,20 @@ expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, r
   reply.send({ test: 'foo' })
 }))
 // typed sync error handler return error
-expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
   expectType<CustomError>(error)
   return { test: 'foo' }
-}))
+})
 // typed async error handler send error
 expectError(server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
   expectType<CustomError>(error)
   reply.send({ test: 'foo' })
 }))
 // typed async error handler return error
-expectError(server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
   expectType<CustomError>(error)
   return { test: 'foo' }
-}))
+})
 
 function notFoundHandler (request: FastifyRequest, reply: FastifyReply) {}
 function notFoundpreHandlerHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
@@ -110,7 +115,9 @@ server.setNotFoundHandler({ preValidation: notFoundpreValidationHandler }, notFo
 server.setNotFoundHandler({ preValidation: notFoundpreValidationAsyncHandler }, notFoundHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler }, notFoundHandler)
 
-function invalidErrorHandler (error: number) {}
+function invalidErrorHandler (error: number) {
+  if (error) throw error
+}
 expectError(server.setErrorHandler(invalidErrorHandler))
 
 server.setSchemaController({
@@ -148,16 +155,30 @@ expectError(server.setReplySerializer(invalidReplySerializer))
 function serializerWithInvalidReturn (payload: unknown, statusCode: number) {}
 expectError(server.setReplySerializer(serializerWithInvalidReturn))
 
-function invalidSchemaErrorFormatter () {}
+function invalidSchemaErrorFormatter (err: Error) {
+  if (err) { throw err }
+}
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
 // test listen method callback
-expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {}))
-expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {}))
-expectAssignable<void>(server.listen(3000, '', (err, address) => {}))
-expectAssignable<void>(server.listen('3000', '', (err, address) => {}))
-expectAssignable<void>(server.listen(3000, (err, address) => {}))
-expectAssignable<void>(server.listen('3000', (err, address) => {}))
+expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen(3000, '', (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', '', (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen(3000, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', (err, address) => {
+  expectType<Error | null>(err)
+}))
 
 // test listen method callback types
 expectAssignable<void>(server.listen('3000', (err, address) => {
@@ -173,13 +194,43 @@ expectAssignable<PromiseLike<string>>(server.listen('3000', '', 0))
 expectAssignable<PromiseLike<string>>(server.listen(3000, ''))
 expectAssignable<PromiseLike<string>>(server.listen('3000', ''))
 
+// Test variadic listen signatures Typescript deprecation
+expectDeprecated(server.listen(3000))
+expectDeprecated(server.listen('3000'))
+expectDeprecated(server.listen(3000, '', 0))
+expectDeprecated(server.listen('3000', '', 0))
+expectDeprecated(server.listen(3000, ''))
+expectDeprecated(server.listen('3000', ''))
+
 // test listen opts objects
+expectAssignable<PromiseLike<string>>(server.listen())
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000 }))
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0' }))
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }))
+expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }))
+expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '::/0', ipv6Only: true }))
+
+expectAssignable<void>(server.listen(() => {}))
 expectAssignable<void>(server.listen({ port: 3000 }, () => {}))
 expectAssignable<void>(server.listen({ port: 3000, host: '0.0.0.0' }, () => {}))
 expectAssignable<void>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }, () => {}))
+expectAssignable<void>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }, () => {}))
+expectAssignable<void>(server.listen({ port: 3000, host: '::/0', ipv6Only: true }, () => {}))
+
+// test listen opts objects Typescript deprectation exclusion
+expectNotDeprecated(server.listen())
+expectNotDeprecated(server.listen({ port: 3000 }))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0' }))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }))
+expectNotDeprecated(server.listen({ port: 3000, host: '::/0', ipv6Only: true }))
+
+expectNotDeprecated(server.listen(() => {}))
+expectNotDeprecated(server.listen({ port: 3000 }, () => {}))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0' }, () => {}))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }, () => {}))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }, () => {}))
+expectNotDeprecated(server.listen({ port: 3000, host: '::/0', ipv6Only: true }, () => {}))
 
 expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as RawReplyDefaultExpression))
 

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

@@ -1,8 +1,15 @@
 import { expectType } from 'tsd'
-import fastify, { FastifyLogFn, LogLevel, FastifyLoggerInstance, FastifyError, FastifyRequest, FastifyReply } from '../../fastify'
+import fastify, {
+  FastifyLogFn,
+  LogLevel,
+  FastifyLoggerInstance,
+  FastifyRequest,
+  FastifyReply,
+  FastifyBaseLogger
+} from '../../fastify'
 import { Server, IncomingMessage, ServerResponse } from 'http'
-import pino from 'pino'
 import * as fs from 'fs'
+import P from 'pino'
 
 expectType<FastifyLoggerInstance>(fastify().log)
 
@@ -15,14 +22,17 @@ class Foo {}
   expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({ foo: 'bar' }))
   expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Error()))
   expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Foo()))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](0))
 })
 
-interface CustomLogger extends FastifyLoggerInstance {
+/*
+// TODO make pino export BaseLogger again
+interface CustomLogger extends FastifyBaseLogger {
   customMethod(msg: string, ...args: unknown[]): void;
 }
 
+//   // ToDo https://github.com/pinojs/pino/issues/1100
 class CustomLoggerImpl implements CustomLogger {
+  level = 'info'
   customMethod (msg: string, ...args: unknown[]) { console.log(msg, args) }
 
   // Implementation signature must be compatible with all overloads of FastifyLogFn
@@ -35,7 +45,9 @@ class CustomLoggerImpl implements CustomLogger {
   fatal (...args: unknown[]) { console.log(args) }
   trace (...args: unknown[]) { console.log(args) }
   debug (...args: unknown[]) { console.log(args) }
-  child () { return new CustomLoggerImpl() }
+  silent (...args: unknown[]) { }
+
+  child (bindings: P.Bindings, options?: P.ChildLoggerOptions): CustomLoggerImpl { return new CustomLoggerImpl() }
 }
 
 const customLogger = new CustomLoggerImpl()
@@ -48,20 +60,21 @@ CustomLoggerImpl
 >({ logger: customLogger })
 
 expectType<CustomLoggerImpl>(serverWithCustomLogger.log)
+*/
 
 const serverWithPino = fastify<
 Server,
 IncomingMessage,
 ServerResponse,
-pino.Logger
+P.Logger
 >({
-  logger: pino({
+  logger: P({
     level: 'info',
     redact: ['x-userinfo']
   })
 })
 
-expectType<pino.Logger>(serverWithPino.log)
+expectType<P.Logger>(serverWithPino.log)
 
 const serverWithLogOptions = fastify<
 Server,
@@ -94,16 +107,16 @@ const serverAutoInferringTypes = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferringTypes.log)
+expectType<FastifyBaseLogger>(serverAutoInferringTypes.log)
 
 const serverWithAutoInferredPino = fastify({
-  logger: pino({
+  logger: P({
     level: 'info',
     redact: ['x-userinfo']
   })
 })
 
-expectType<pino.Logger>(serverWithAutoInferredPino.log)
+expectType<P.Logger>(serverWithAutoInferredPino.log)
 
 const serverAutoInferredFileOption = fastify({
   logger: {
@@ -112,7 +125,7 @@ const serverAutoInferredFileOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredFileOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredFileOption.log)
 
 const serverAutoInferredPinoPrettyBooleanOption = fastify({
   logger: {
@@ -120,7 +133,7 @@ const serverAutoInferredPinoPrettyBooleanOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredPinoPrettyBooleanOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredPinoPrettyBooleanOption.log)
 
 const serverAutoInferredPinoPrettyObjectOption = fastify({
   logger: {
@@ -141,7 +154,7 @@ const serverAutoInferredPinoPrettyObjectOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredPinoPrettyObjectOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredPinoPrettyObjectOption.log)
 
 const serverAutoInferredSerializerObjectOption = fastify({
   logger: {
@@ -176,10 +189,26 @@ const serverAutoInferredSerializerObjectOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredSerializerObjectOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredSerializerObjectOption.log)
 
 const passStreamAsOption = fastify({
   logger: {
     stream: fs.createWriteStream('/tmp/stream.out')
   }
 })
+
+expectType<FastifyBaseLogger>(passStreamAsOption.log)
+
+const passPinoOption = fastify({
+  logger: {
+    redact: ['custom'],
+    messageKey: 'msg',
+    nestedKey: 'nested',
+    prettyPrint: {
+
+    },
+    enabled: true
+  }
+})
+
+expectType<FastifyBaseLogger>(passPinoOption.log)

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

@@ -4,6 +4,7 @@ import { RawServerDefault, RawReplyDefaultExpression, ContextConfigDefault } fro
 import { FastifyLoggerInstance } from '../../types/logger'
 import { RouteGenericInterface } from '../../types/route'
 import { FastifyInstance } from '../../types/instance'
+import { Buffer } from 'buffer'
 
 const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<RawReplyDefaultExpression>(reply.raw)
@@ -28,7 +29,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<() => number>(reply.getResponseTime)
   expectType<(contentType: string) => FastifyReply>(reply.type)
   expectType<(fn: (payload: any) => string) => FastifyReply>(reply.serializer)
-  expectType<(payload: any) => string>(reply.serialize)
+  expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)
   expectType<(fulfilled: () => void, rejected: (err: Error) => void) => void>(reply.then)
   expectType<FastifyInstance>(reply.server)
 }

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

@@ -1,5 +1,5 @@
 import fastify, { FastifyInstance, FastifyRequest, FastifyReply, RouteHandlerMethod } from '../../fastify'
-import { expectType, expectError, expectAssignable } from 'tsd'
+import { expectType, expectError, expectAssignable, printType } from 'tsd'
 import { HTTPMethods } from '../../types/utils'
 import * as http from 'http'
 import { RequestPayload } from '../../types/hooks'
@@ -44,7 +44,13 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
   expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', {}, routeHandler))
   expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', { handler: routeHandler }))
 
-  expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', { handler: routeHandler, errorHandler: (error, request, reply) => reply.send('error') }))
+  expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', {
+    handler: routeHandler,
+    errorHandler: (error, request, reply) => {
+      expectType<FastifyError>(error)
+      reply.send('error')
+    }
+  }))
 
   interface BodyInterface { prop: string }
   interface QuerystringInterface { prop: number }

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' }
-    }
-  },
-  () => { }
-))