fastify 3.26.0 → 4.0.0-alpha.1

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '3.26.0'
+const VERSION = '4.0.0-alpha.1'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -10,6 +10,7 @@ let lightMyRequest
 const {
   kAvvioBoot,
   kChildren,
+  kServerBindings,
   kBodyLimit,
   kRoutePrefix,
   kLogLevel,
@@ -26,10 +27,12 @@ const {
   kOptions,
   kPluginNameChain,
   kSchemaErrorFormatter,
-  kErrorHandler
+  kErrorHandler,
+  kKeepAliveConnections,
+  kFourOhFourContext
 } = require('./lib/symbols.js')
 
-const { createServer } = require('./lib/server')
+const createServer = require('./lib/server')
 const Reply = require('./lib/reply')
 const Request = require('./lib/request')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
@@ -45,18 +48,23 @@ const build404 = require('./lib/fourOhFour')
 const getSecuredInitialConfig = require('./lib/initialConfigValidation')
 const override = require('./lib/pluginOverride')
 const warning = require('./lib/warnings')
+const noopSet = require('./lib/noop-set')
 const { defaultInitOptions } = getSecuredInitialConfig
 
 const {
   FST_ERR_BAD_URL,
-  FST_ERR_MISSING_MIDDLEWARE
+  AVVIO_ERRORS_MAP,
+  appendStackTrace
 } = require('./lib/errors')
 
+const { buildErrorHandler } = require('./lib/error-handler.js')
+
 const onBadUrlContext = {
   config: {
   },
   onSend: [],
-  onError: []
+  onError: [],
+  [kFourOhFourContext]: null
 }
 
 function defaultBuildPrettyMeta (route) {
@@ -72,21 +80,6 @@ function defaultBuildPrettyMeta (route) {
   return Object.assign({}, cleanKeys)
 }
 
-function defaultErrorHandler (error, request, reply) {
-  if (reply.statusCode < 500) {
-    reply.log.info(
-      { res: reply, err: error },
-      error && error.message
-    )
-  } else {
-    reply.log.error(
-      { req: request, res: reply, err: error },
-      error && error.message
-    )
-  }
-  reply.send(error)
-}
-
 function fastify (options) {
   // Options validations
   options = options || {}
@@ -111,7 +104,6 @@ function fastify (options) {
   const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
   const bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
   const disableRequestLogging = options.disableRequestLogging || false
-  const exposeHeadRoutes = options.exposeHeadRoutes != null ? options.exposeHeadRoutes : false
 
   const ajvOptions = Object.assign({
     customOptions: {},
@@ -133,6 +125,7 @@ function fastify (options) {
   // Update the options with the fixed values
   options.connectionTimeout = options.connectionTimeout || defaultInitOptions.connectionTimeout
   options.keepAliveTimeout = options.keepAliveTimeout || defaultInitOptions.keepAliveTimeout
+  options.forceCloseConnections = typeof options.forceCloseConnections === 'boolean' ? options.forceCloseConnections : defaultInitOptions.forceCloseConnections
   options.maxRequestsPerSocket = options.maxRequestsPerSocket || defaultInitOptions.maxRequestsPerSocket
   options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
   options.logger = logger
@@ -143,9 +136,12 @@ function fastify (options) {
   options.disableRequestLogging = disableRequestLogging
   options.ajv = ajvOptions
   options.clientErrorHandler = options.clientErrorHandler || defaultClientErrorHandler
-  options.exposeHeadRoutes = exposeHeadRoutes
 
   const initialConfig = getSecuredInitialConfig(options)
+  const keepAliveConnections = options.forceCloseConnections === true ? new Set() : noopSet()
+
+  // exposeHeadRoutes have its defult set from the validatorfrom the validatorfrom the validatorfrom the validator
+  options.exposeHeadRoutes = initialConfig.exposeHeadRoutes
 
   let constraints = options.constraints
   if (options.versioning) {
@@ -169,14 +165,15 @@ function fastify (options) {
   // Default router
   const router = buildRouting({
     config: {
-      defaultRoute: defaultRoute,
-      onBadUrl: onBadUrl,
-      constraints: constraints,
+      defaultRoute,
+      onBadUrl,
+      constraints,
       ignoreTrailingSlash: options.ignoreTrailingSlash || defaultInitOptions.ignoreTrailingSlash,
       maxParamLength: options.maxParamLength || defaultInitOptions.maxParamLength,
       caseSensitive: options.caseSensitive,
       buildPrettyMeta: defaultBuildPrettyMeta
-    }
+    },
+    keepAliveConnections
   })
 
   // 404 router, used for handling encapsulated 404 handlers
@@ -200,8 +197,10 @@ function fastify (options) {
       closing: false,
       started: false
     },
+    [kKeepAliveConnections]: keepAliveConnections,
     [kOptions]: options,
     [kChildren]: [],
+    [kServerBindings]: [],
     [kBodyLimit]: bodyLimit,
     [kRoutePrefix]: '',
     [kLogLevel]: '',
@@ -209,7 +208,7 @@ function fastify (options) {
     [kHooks]: new Hooks(),
     [kSchemaController]: schemaController,
     [kSchemaErrorFormatter]: null,
-    [kErrorHandler]: defaultErrorHandler,
+    [kErrorHandler]: buildErrorHandler(),
     [kReplySerializerDefault]: null,
     [kContentTypeParser]: new ContentTypeParser(
       bodyLimit,
@@ -259,17 +258,19 @@ function fastify (options) {
     },
     // expose logger instance
     log: logger,
+    // type provider
+    withTypeProvider,
     // hooks
-    addHook: addHook,
+    addHook,
     // schemas
-    addSchema: addSchema,
+    addSchema,
     getSchema: schemaController.getSchema.bind(schemaController),
     getSchemas: schemaController.getSchemas.bind(schemaController),
-    setValidatorCompiler: setValidatorCompiler,
-    setSerializerCompiler: setSerializerCompiler,
-    setSchemaController: setSchemaController,
-    setReplySerializer: setReplySerializer,
-    setSchemaErrorFormatter: setSchemaErrorFormatter,
+    setValidatorCompiler,
+    setSerializerCompiler,
+    setSchemaController,
+    setReplySerializer,
+    setSchemaErrorFormatter,
     // custom parsers
     addContentTypeParser: ContentTypeParser.helpers.addContentTypeParser,
     hasContentTypeParser: ContentTypeParser.helpers.hasContentTypeParser,
@@ -285,8 +286,14 @@ function fastify (options) {
     close: null,
     printPlugins: null,
     // http server
-    listen: listen,
-    server: server,
+    listen,
+    server,
+    addresses: function () {
+      /* istanbul ignore next */
+      const binded = this[kServerBindings].map(b => b.address())
+      binded.push(this.server.address())
+      return binded.filter(adr => adr)
+    },
     // extend fastify objects
     decorate: decorator.add,
     hasDecorator: decorator.exist,
@@ -295,19 +302,16 @@ function fastify (options) {
     hasRequestDecorator: decorator.existRequest,
     hasReplyDecorator: decorator.existReply,
     // fake http injection
-    inject: inject,
+    inject,
     // pretty print of the registered routes
     printRoutes,
     // custom error handling
-    setNotFoundHandler: setNotFoundHandler,
-    setErrorHandler: setErrorHandler,
+    setNotFoundHandler,
+    setErrorHandler,
     // Set fastify initial configuration options read-only object
     initialConfig
   }
 
-  fastify[kReply].prototype.server = fastify
-  fastify[kRequest].prototype.server = fastify
-
   Object.defineProperties(fastify, {
     pluginName: {
       get () {
@@ -331,16 +335,11 @@ function fastify (options) {
     },
     errorHandler: {
       get () {
-        return this[kErrorHandler]
+        return this[kErrorHandler].func
       }
     }
   })
 
-  // We are adding `use` to the fastify prototype so the user
-  // can still access it (and get the expected error), but `decorate`
-  // will not detect it, and allow the user to override it.
-  Object.setPrototypeOf(fastify, { use })
-
   if (options.schemaErrorFormatter) {
     validateSchemaErrorFormatter(options.schemaErrorFormatter)
     fastify[kSchemaErrorFormatter] = options.schemaErrorFormatter.bind(fastify)
@@ -375,6 +374,15 @@ function fastify (options) {
       if (fastify[kState].listening) {
         // No new TCP connections are accepted
         instance.server.close(done)
+
+        for (const conn of fastify[kKeepAliveConnections]) {
+          // We must invoke the destroy method instead of merely unreffing
+          // the sockets. If we only unref, then the callback passed to
+          // `fastify.close` will never be invoked; nor will any of the
+          // registered `onClose` hooks.
+          conn.destroy()
+          fastify[kKeepAliveConnections].delete(conn)
+        }
       } else {
         done(null)
       }
@@ -483,6 +491,13 @@ function fastify (options) {
     }
 
     function manageErr (err) {
+      // If the error comes out of Avvio's Error codes
+      // We create a make and preserve the previous error
+      // as cause
+      err = err != null && AVVIO_ERRORS_MAP[err.code] != null
+        ? appendStackTrace(err, new AVVIO_ERRORS_MAP[err.code](err.message))
+        : err
+
       if (cb) {
         if (err) {
           cb(err)
@@ -498,15 +513,16 @@ function fastify (options) {
     }
   }
 
-  function use () {
-    throw new FST_ERR_MISSING_MIDDLEWARE()
+  // Used exclusively in TypeScript contexts to enable auto type inference from JSON schema.
+  function withTypeProvider () {
+    return this
   }
 
   // wrapper that we expose to the user for hooks handling
   function addHook (name, fn) {
     throwIfAlreadyStarted('Cannot call "addHook" when fastify instance is already started!')
 
-    if (name === 'onSend' || name === 'preSerialization' || name === 'onError') {
+    if (name === 'onSend' || name === 'preSerialization' || name === 'onError' || name === 'preParsing') {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 4) {
         throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
       }
@@ -514,7 +530,7 @@ function fastify (options) {
       if (fn.constructor.name === 'AsyncFunction' && fn.length !== 0) {
         throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
       }
-    } else if (name !== 'preParsing') {
+    } else {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
         throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
       }
@@ -524,6 +540,9 @@ function fastify (options) {
       this.onClose(fn)
     } else if (name === 'onReady') {
       this[kHooks].add(name, fn)
+    } else if (name === 'onRoute') {
+      this[kHooks].validate(name, fn)
+      this[kHooks].add(name, fn)
     } else {
       this.after((err, done) => {
         _addHook.call(this, name, fn)
@@ -652,7 +671,7 @@ function fastify (options) {
   function setErrorHandler (func) {
     throwIfAlreadyStarted('Cannot call "setErrorHandler" when fastify instance is already started!')
 
-    this[kErrorHandler] = func.bind(this)
+    this[kErrorHandler] = buildErrorHandler(this[kErrorHandler], func.bind(this))
     return this
   }