fastify 4.11.0 → 4.13.0

package/fastify.d.ts

@@ -1,26 +1,197 @@
 import * as http from 'http'
 import * as http2 from 'http2'
 import * as https from 'https'
-import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { Socket } from 'net'
 
-import { FastifyRequest, RequestGenericInterface } from './types/request'
-import { RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression } from './types/utils'
-import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions } from './types/logger'
-import { FastifyInstance } from './types/instance'
-import { FastifyServerFactory } from './types/serverFactory'
-import { Options as AjvOptions } from '@fastify/ajv-compiler'
-import { Options as FJSOptions } from '@fastify/fast-json-stringify-compiler'
+import { Options as AjvOptions, ValidatorCompiler } from '@fastify/ajv-compiler'
 import { FastifyError } from '@fastify/error'
+import { Options as FJSOptions, SerializerCompiler } from '@fastify/fast-json-stringify-compiler'
+import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse, CallbackFunc as LightMyRequestCallback } from 'light-my-request'
+
+import { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
+import { FastifyContext, FastifyContextConfig } from './types/context'
+import { FastifyErrorCodes } from './types/errors'
+import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler } from './types/hooks'
+import { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
+import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions, FastifyLogFn, LogLevel } from './types/logger'
+import { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
+import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './types/register'
 import { FastifyReply } from './types/reply'
-import { FastifySchemaValidationError } from './types/schema'
-import { ConstructorAction, ProtoAction } from "./types/content-type-parser";
-import { Socket } from 'net'
-import { ValidatorCompiler } from '@fastify/ajv-compiler'
-import { SerializerCompiler } from '@fastify/fast-json-stringify-compiler'
-import { FastifySchema } from './types/schema'
-import { FastifyContextConfig } from './types/context'
+import { FastifyRequest, RequestGenericInterface } from './types/request'
+import { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface } from './types/route'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError } from './types/schema'
+import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault } from './types/type-provider'
-import { FastifyErrorCodes } from './types/errors'
+import { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
+
+declare module '@fastify/error' {
+  interface FastifyError {
+    validation?: fastify.ValidationResult[];
+    validationContext?: 'body' | 'headers' | 'parameters' | 'querystring';
+  }
+}
+
+type Fastify = typeof fastify
+
+declare namespace fastify {
+  export const errorCodes: FastifyErrorCodes;
+
+  export type FastifyHttp2SecureOptions<
+    Server extends http2.Http2SecureServer,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    https: http2.SecureServerOptions,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttp2Options<
+    Server extends http2.Http2Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttpsOptions<
+    Server extends https.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    https: https.ServerOptions | null
+  }
+
+  export type FastifyHttpOptions<
+    Server extends http.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http?: http.ServerOptions | null
+  }
+
+  type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+
+  export interface ConnectionError extends Error {
+    code: string,
+    bytesParsed: number,
+    rawPacket: {
+      type: string,
+      data: number[]
+    }
+  }
+
+  type TrustProxyFunction = (address: string, hop: number) => boolean
+
+  /**
+   * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
+   */
+  export type FastifyServerOptions<
+    RawServer extends RawServerBase = RawServerDefault,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = {
+    ignoreTrailingSlash?: boolean,
+    ignoreDuplicateSlashes?: boolean,
+    connectionTimeout?: number,
+    keepAliveTimeout?: number,
+    maxRequestsPerSocket?: number,
+    forceCloseConnections?: boolean | 'idle',
+    requestTimeout?: number,
+    pluginTimeout?: number,
+    bodyLimit?: number,
+    maxParamLength?: number,
+    disableRequestLogging?: boolean,
+    exposeHeadRoutes?: boolean,
+    onProtoPoisoning?: ProtoAction,
+    onConstructorPoisoning?: ConstructorAction,
+    logger?: boolean | FastifyLoggerOptions<RawServer> & PinoLoggerOptions | Logger,
+    serializerOpts?: FJSOptions | Record<string, unknown>,
+    serverFactory?: FastifyServerFactory<RawServer>,
+    caseSensitive?: boolean,
+    requestIdHeader?: string | false,
+    requestIdLogLabel?: string;
+    jsonShorthand?: boolean;
+    genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>) => string,
+    trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
+    querystringParser?: (str: string) => { [key: string]: unknown },
+    /**
+     * @deprecated Prefer using the `constraints.version` property
+     */
+    versioning?: {
+      storage(): {
+        get(version: string): string | null,
+        set(version: string, store: Function): void
+        del(version: string): void,
+        empty(): void
+      },
+      deriveVersion<Context>(req: Object, ctx?: Context): string // not a fan of using Object here. Also what is Context? Can either of these be better defined?
+    },
+    constraints?: {
+      [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
+    },
+    schemaController?: {
+      bucket?: (parentSchemas?: unknown) => {
+        add(schema: unknown): FastifyInstance;
+        getSchema(schemaId: string): unknown;
+        getSchemas(): Record<string, unknown>;
+      };
+      compilersFactory?: {
+        buildValidator?: ValidatorCompiler;
+        buildSerializer?: SerializerCompiler;
+      };
+    };
+    return503OnClosing?: boolean,
+    ajv?: {
+      customOptions?: AjvOptions,
+      plugins?: (Function | [Function, unknown])[]
+    },
+    frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
+      error: FastifyError,
+      req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
+      res: FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RequestGeneric, FastifyContextConfig, SchemaCompiler, TypeProvider>
+    ) => void,
+    rewriteUrl?: (req: RawRequestDefaultExpression<RawServer>) => string,
+    schemaErrorFormatter?: (errors: FastifySchemaValidationError[], dataVar: string) => Error,
+    /**
+     * listener to error events emitted by client connections
+     */
+    clientErrorHandler?: (error: ConnectionError, socket: Socket) => void
+  }
+
+  export interface ValidationResult {
+    keyword: string;
+    instancePath: string;
+    schemaPath: string;
+    params: Record<string, string | string[]>;
+    message?: string;
+  }
+
+  /* Export additional types */
+  export type {
+    LightMyRequestChain, InjectOptions, LightMyRequestResponse, LightMyRequestCallback, // 'light-my-request'
+    FastifyRequest, RequestGenericInterface, // './types/request'
+    FastifyReply, // './types/reply'
+    FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin, // './types/plugin'
+    FastifyListenOptions, FastifyInstance, PrintRoutesOptions, // './types/instance'
+    FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel, // './types/logger'
+    FastifyContext, FastifyContextConfig, // './types/context'
+    RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface, // './types/route'
+    FastifyRegister, FastifyRegisterOptions, RegisterOptions, // './types/register'
+    FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction, // './types/content-type-parser'
+    FastifyError, // '@fastify/error'
+    FastifySchema, FastifySchemaCompiler, // './types/schema'
+    HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault, // './types/utils'
+    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, // './types/hooks'
+    FastifyServerFactory, FastifyServerFactoryHandler, // './types/serverFactory'
+    FastifyTypeProvider, FastifyTypeProviderDefault, // './types/type-provider'
+    FastifyErrorCodes, // './types/errors'
+  }
+  // named export
+  // import { plugin } from 'plugin'
+  // const { plugin } = require('plugin')
+  export const fastify: Fastify
+  // default export
+  // import plugin from 'plugin'
+  export { fastify as default }
+}
 
 /**
  * Fastify factory function for the standard fastify http, https, or http2 server instance.
@@ -34,183 +205,34 @@ declare function fastify<
   Server extends http2.Http2SecureServer,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts: FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+>(opts: fastify.FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends http2.Http2Server,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts: FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+>(opts: fastify.FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends https.Server,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts: FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+>(opts: fastify.FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends http.Server,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts?: FastifyServerOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
-
-declare namespace fastify {
-  export const errorCodes: FastifyErrorCodes;
-}
-
-export default fastify
-
-export type FastifyHttp2SecureOptions<
-  Server extends http2.Http2SecureServer,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = FastifyServerOptions<Server, Logger> & {
-  http2: true,
-  https: http2.SecureServerOptions,
-  http2SessionTimeout?: number
-}
-
-export type FastifyHttp2Options<
-  Server extends http2.Http2Server,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = FastifyServerOptions<Server, Logger> & {
-  http2: true,
-  http2SessionTimeout?: number
-}
-
-export type FastifyHttpsOptions<
-  Server extends https.Server,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = FastifyServerOptions<Server, Logger> & {
-  https: https.ServerOptions | null
-}
-
-type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
-
-export interface ConnectionError extends Error {
-  code: string,
-  bytesParsed: number,
-  rawPacket: {
-    type: string,
-    data: number[]
-  }
-}
-
-/**
- * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
- */
-export type FastifyServerOptions<
-  RawServer extends RawServerBase = RawServerDefault,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = {
-  ignoreTrailingSlash?: boolean,
-  ignoreDuplicateSlashes?: boolean,
-  connectionTimeout?: number,
-  keepAliveTimeout?: number,
-  maxRequestsPerSocket?: number,
-  forceCloseConnections?: boolean | 'idle',
-  requestTimeout?: number,
-  pluginTimeout?: number,
-  bodyLimit?: number,
-  maxParamLength?: number,
-  disableRequestLogging?: boolean,
-  exposeHeadRoutes?: boolean,
-  onProtoPoisoning?: ProtoAction,
-  onConstructorPoisoning?: ConstructorAction,
-  logger?: boolean | FastifyLoggerOptions<RawServer> & PinoLoggerOptions | Logger,
-  serializerOpts?: FJSOptions | Record<string, unknown>,
-  serverFactory?: FastifyServerFactory<RawServer>,
-  caseSensitive?: boolean,
-  requestIdHeader?: string | false,
-  requestIdLogLabel?: string;
-  jsonShorthand?: boolean;
-  genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>) => string,
-  trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
-  querystringParser?: (str: string) => { [key: string]: unknown },
-  /**
-   * @deprecated Prefer using the `constraints.version` property
-   */
-  versioning?: {
-    storage(): {
-      get(version: string): string | null,
-      set(version: string, store: Function): void
-      del(version: string): void,
-      empty(): void
-    },
-    deriveVersion<Context>(req: Object, ctx?: Context): string // not a fan of using Object here. Also what is Context? Can either of these be better defined?
-  },
-  constraints?: {
-    [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
-  },
-  schemaController?: {
-    bucket?: (parentSchemas?: unknown) => {
-      add(schema: unknown): FastifyInstance;
-      getSchema(schemaId: string): unknown;
-      getSchemas(): Record<string, unknown>;
-    };
-    compilersFactory?: {
-      buildValidator?: ValidatorCompiler;
-      buildSerializer?: SerializerCompiler;
-    };
-  };
-  return503OnClosing?: boolean,
-  ajv?: {
-    customOptions?: AjvOptions,
-    plugins?: (Function | [Function, unknown])[]
-  },
-  frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
-    error: FastifyError,
-    req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
-    res: FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RequestGeneric, FastifyContextConfig, SchemaCompiler, TypeProvider>
-  ) => void,
-  rewriteUrl?: (req: RawRequestDefaultExpression<RawServer>) => string,
-  schemaErrorFormatter?: (errors: FastifySchemaValidationError[], dataVar: string) => Error,
-  /**
-   * listener to error events emitted by client connections
-   */
-  clientErrorHandler?: (error: ConnectionError, socket: Socket) => void
-}
-
-type TrustProxyFunction = (address: string, hop: number) => boolean
-
-declare module '@fastify/error' {
-  interface FastifyError {
-    validation?: ValidationResult[];
-    validationContext?: 'body' | 'headers' | 'parameters' | 'querystring';
-  }
-}
-
-export interface ValidationResult {
-  keyword: string;
-  instancePath: string;
-  schemaPath: string;
-  params: Record<string, string | string[]>;
-  message?: string;
-}
+>(opts?: fastify.FastifyHttpOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
-/* Export all additional types */
-export type { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse, CallbackFunc as LightMyRequestCallback } from 'light-my-request'
-export { FastifyRequest, RequestGenericInterface } from './types/request'
-export { FastifyReply } from './types/reply'
-export { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
-export { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
-export { FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel } from './types/logger'
-export { FastifyContext, FastifyContextConfig } from './types/context'
-export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface } from './types/route'
-export * from './types/register'
-export { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
-export { FastifyError } from '@fastify/error'
-export { FastifySchema, FastifySchemaCompiler } from './types/schema'
-export { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
-export * from './types/hooks'
-export { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
-export { FastifyTypeProvider, FastifyTypeProviderDefault } from './types/type-provider'
-export { FastifyErrorCodes } from './types/errors'
-export { fastify }
+// CJS export
+// const fastify = require('fastify')
+export = fastify

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.11.0'
+const VERSION = '4.13.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -59,7 +59,17 @@ const { defaultInitOptions } = getSecuredInitialConfig
 const {
   FST_ERR_ASYNC_CONSTRAINT,
   FST_ERR_BAD_URL,
-  FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE
+  FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE,
+  FST_ERR_OPTIONS_NOT_OBJ,
+  FST_ERR_QSP_NOT_FN,
+  FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN,
+  FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ,
+  FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR,
+  FST_ERR_VERSION_CONSTRAINT_NOT_STR,
+  FST_ERR_INSTANCE_ALREADY_LISTENING,
+  FST_ERR_REOPENED_CLOSE_SERVER,
+  FST_ERR_ROUTE_REWRITE_NOT_STR,
+  FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN
 } = errorCodes
 
 const { buildErrorHandler } = require('./lib/error-handler.js')
@@ -90,15 +100,15 @@ function fastify (options) {
   options = options || {}
 
   if (typeof options !== 'object') {
-    throw new TypeError('Options must be an object')
+    throw new FST_ERR_OPTIONS_NOT_OBJ()
   }
 
   if (options.querystringParser && typeof options.querystringParser !== 'function') {
-    throw new Error(`querystringParser option should be a function, instead got '${typeof options.querystringParser}'`)
+    throw new FST_ERR_QSP_NOT_FN(typeof options.querystringParser)
   }
 
   if (options.schemaController && options.schemaController.bucket && typeof options.schemaController.bucket !== 'function') {
-    throw new Error(`schemaController.bucket option should be a function, instead got '${typeof options.schemaController.bucket}'`)
+    throw new FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN(typeof options.schemaController.bucket)
   }
 
   validateBodyLimitOption(options.bodyLimit)
@@ -117,10 +127,10 @@ function fastify (options) {
 
   // Ajv options
   if (!ajvOptions.customOptions || Object.prototype.toString.call(ajvOptions.customOptions) !== '[object Object]') {
-    throw new Error(`ajv.customOptions option should be an object, instead got '${typeof ajvOptions.customOptions}'`)
+    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ(typeof ajvOptions.customOptions)
   }
   if (!ajvOptions.plugins || !Array.isArray(ajvOptions.plugins)) {
-    throw new Error(`ajv.plugins option should be an array, instead got '${typeof ajvOptions.plugins}'`)
+    throw new FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR(typeof ajvOptions.plugins)
   }
 
   // Instance Fastify components
@@ -156,7 +166,7 @@ function fastify (options) {
         deriveConstraint: options.versioning.deriveVersion,
         validate (value) {
           if (typeof value !== 'string') {
-            throw new Error('Version constraint should be a string.')
+            throw new FST_ERR_VERSION_CONSTRAINT_NOT_STR()
           }
         }
       }
@@ -463,7 +473,7 @@ function fastify (options) {
   return fastify
 
   function throwIfAlreadyStarted (msg) {
-    if (fastify[kState].started) throw new Error(msg)
+    if (fastify[kState].started) throw new FST_ERR_INSTANCE_ALREADY_LISTENING(msg)
   }
 
   // HTTP injection handling
@@ -479,7 +489,7 @@ function fastify (options) {
     if (fastify[kState].started) {
       if (fastify[kState].closing) {
         // Force to return an error
-        const error = new Error('Server is closed')
+        const error = new FST_ERR_REOPENED_CLOSE_SERVER()
         if (cb) {
           cb(error)
           return
@@ -564,7 +574,7 @@ function fastify (options) {
 
   // wrapper that we expose to the user for hooks handling
   function addHook (name, fn) {
-    throwIfAlreadyStarted('Cannot call "addHook" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "addHook"!')
 
     if (fn == null) {
       throw new errorCodes.FST_ERR_HOOK_INVALID_HANDLER(name, fn)
@@ -607,7 +617,7 @@ function fastify (options) {
 
   // wrapper that we expose to the user for schemas handling
   function addSchema (schema) {
-    throwIfAlreadyStarted('Cannot call "addSchema" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "addSchema"!')
     this[kSchemaController].add(schema)
     this[kChildren].forEach(child => child.addSchema(schema))
     return this
@@ -620,22 +630,30 @@ function fastify (options) {
       return
     }
 
-    const body = JSON.stringify({
-      error: http.STATUS_CODES['400'],
-      message: 'Client Error',
-      statusCode: 400
-    })
+    let body, errorCode, errorStatus, errorLabel
+
+    if (err.code === 'ERR_HTTP_REQUEST_TIMEOUT') {
+      errorCode = '408'
+      errorStatus = http.STATUS_CODES[errorCode]
+      body = `{"error":"${errorStatus}","message":"Client Timeout","statusCode":408}`
+      errorLabel = 'timeout'
+    } else {
+      errorCode = '400'
+      errorStatus = http.STATUS_CODES[errorCode]
+      body = `{"error":"${errorStatus}","message":"Client Error","statusCode":400}`
+      errorLabel = 'error'
+    }
 
     // Most devs do not know what to do with this error.
     // In the vast majority of cases, it's a network error and/or some
     // config issue on the load balancer side.
-    this.log.trace({ err }, 'client error')
+    this.log.trace({ err }, `client ${errorLabel}`)
     // Copying standard node behaviour
     // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
 
     // If the socket is not writable, there is no reason to try to send data.
     if (socket.writable) {
-      socket.write(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
+      socket.write(`HTTP/1.1 ${errorCode} ${errorStatus}\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
     }
     socket.destroy(err)
   }
@@ -697,33 +715,33 @@ function fastify (options) {
   }
 
   function setNotFoundHandler (opts, handler) {
-    throwIfAlreadyStarted('Cannot call "setNotFoundHandler" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setNotFoundHandler"!')
 
     fourOhFour.setNotFoundHandler.call(this, opts, handler, avvio, router.routeHandler)
     return this
   }
 
   function setValidatorCompiler (validatorCompiler) {
-    throwIfAlreadyStarted('Cannot call "setValidatorCompiler" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setValidatorCompiler"!')
     this[kSchemaController].setValidatorCompiler(validatorCompiler)
     return this
   }
 
   function setSchemaErrorFormatter (errorFormatter) {
-    throwIfAlreadyStarted('Cannot call "setSchemaErrorFormatter" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setSchemaErrorFormatter"!')
     validateSchemaErrorFormatter(errorFormatter)
     this[kSchemaErrorFormatter] = errorFormatter.bind(this)
     return this
   }
 
   function setSerializerCompiler (serializerCompiler) {
-    throwIfAlreadyStarted('Cannot call "setSerializerCompiler" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setSerializerCompiler"!')
     this[kSchemaController].setSerializerCompiler(serializerCompiler)
     return this
   }
 
   function setSchemaController (schemaControllerOpts) {
-    throwIfAlreadyStarted('Cannot call "setSchemaController" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setSchemaController"!')
     const old = this[kSchemaController]
     const schemaController = SchemaController.buildSchemaController(old, Object.assign({}, old.opts, schemaControllerOpts))
     this[kSchemaController] = schemaController
@@ -733,7 +751,7 @@ function fastify (options) {
   }
 
   function setReplySerializer (replySerializer) {
-    throwIfAlreadyStarted('Cannot call "setReplySerializer" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setReplySerializer"!')
 
     this[kReplySerializerDefault] = replySerializer
     return this
@@ -741,7 +759,7 @@ function fastify (options) {
 
   // wrapper that we expose to the user for configure the custom error handler
   function setErrorHandler (func) {
-    throwIfAlreadyStarted('Cannot call "setErrorHandler" when fastify instance is already started!')
+    throwIfAlreadyStarted('Cannot call "setErrorHandler"!')
 
     this[kErrorHandler] = buildErrorHandler(this[kErrorHandler], func.bind(this))
     return this
@@ -766,7 +784,8 @@ function fastify (options) {
           if (typeof url === 'string') {
             req.url = url
           } else {
-            req.destroy(new Error(`Rewrite url for "${req.url}" needs to be of type "string" but received "${typeof url}"`))
+            const err = new FST_ERR_ROUTE_REWRITE_NOT_STR(req.url, typeof url)
+            req.destroy(err)
           }
         }
       }
@@ -779,9 +798,9 @@ fastify.errorCodes = errorCodes
 
 function validateSchemaErrorFormatter (schemaErrorFormatter) {
   if (typeof schemaErrorFormatter !== 'function') {
-    throw new Error(`schemaErrorFormatter option should be a function, instead got ${typeof schemaErrorFormatter}`)
+    throw new FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN(typeof schemaErrorFormatter)
   } else if (schemaErrorFormatter.constructor.name === 'AsyncFunction') {
-    throw new Error('schemaErrorFormatter option should not be an async function')
+    throw new FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN('AsyncFunction')
   }
 }