fastify 3.26.0 → 4.0.0-alpha.1

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

@@ -10,6 +10,7 @@ import { expectAssignable, expectError, expectType } from 'tsd'
 import { FastifyRequest } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { HookHandlerDoneFunction } from '../../types/hooks'
+import { FastifySchemaControllerOptions } from '../../types/schema'
 
 const server = fastify()
 
@@ -30,6 +31,7 @@ expectType<string>(server.printPlugins())
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
+    expectType<FastifyError>(error)
     expectAssignable<FastifyInstance>(this)
   })
 )
@@ -46,14 +48,18 @@ 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 {
-  private __brand: any;
+  private __brand: any
 }
 interface ReplyPayload {
   Reply: {
@@ -81,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() }
@@ -109,9 +115,34 @@ 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({
+  bucket: (parentSchemas: unknown) => {
+    return {
+      addSchema (schema: unknown) {
+        expectType<unknown>(schema)
+        expectType<FastifyInstance>(server.addSchema({ type: 'null' }))
+        return server.addSchema({ type: 'null' })
+      },
+      getSchema (schemaId: string) {
+        expectType<string>(schemaId)
+        return server.getSchema('SchemaId')
+      },
+      getSchemas () {
+        expectType<Record<string, unknown>>(server.getSchemas())
+        return server.getSchemas()
+      }
+    }
+  }
+})
+
+function invalidSchemaController (schemaControllerOptions: FastifySchemaControllerOptions) {}
+expectError(server.setSchemaController(invalidSchemaController))
+
 server.setReplySerializer(function (payload, statusCode) {
   expectType<unknown>(payload)
   expectType<number>(statusCode)
@@ -124,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) => {
@@ -171,6 +216,7 @@ type InitialConfig = Readonly<{
   keepAliveTimeout?: number,
   bodyLimit?: number,
   caseSensitive?: boolean,
+  forceCloseConnections?: boolean,
   http2?: boolean,
   https?: boolean | Readonly<{ allowHTTP1: boolean }>,
   ignoreTrailingSlash?: boolean,

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