fastify 3.26.0 → 4.0.0-alpha.1

package/lib/route.js

@@ -18,7 +18,9 @@ const {
 const {
   FST_ERR_SCH_VALIDATION_BUILD,
   FST_ERR_SCH_SERIALIZATION_BUILD,
-  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE
+  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE,
+  FST_ERR_DUPLICATED_ROUTE,
+  FST_ERR_INVALID_URL
 } = require('./errors')
 
 const {
@@ -26,21 +28,20 @@ const {
   kLogLevel,
   kLogSerializers,
   kHooks,
-  kHooksDeprecatedPreParsing,
   kSchemaController,
   kOptions,
-  kContentTypeParser,
-  kReply,
   kReplySerializerDefault,
   kReplyIsError,
-  kRequest,
   kRequestPayloadStream,
   kDisableRequestLogging,
   kSchemaErrorFormatter,
-  kErrorHandler
+  kErrorHandler,
+  kHasBeenDecorated
 } = require('./symbols.js')
+const { buildErrorHandler } = require('./error-handler')
 
 function buildRouting (options) {
+  const { keepAliveConnections } = options
   const router = FindMyWay(options.config)
 
   let avvio
@@ -98,6 +99,10 @@ function buildRouting (options) {
 
   // Convert shorthand to extended route declaration
   function prepareRoute (method, url, options, handler) {
+    if (typeof url !== 'string') {
+      throw new FST_ERR_INVALID_URL(typeof url)
+    }
+
     if (!handler && typeof options === 'function') {
       handler = options // for support over direct function calls such as fastify.get() options are reused as the handler
       options = {}
@@ -130,22 +135,17 @@ function buildRouting (options) {
 
     throwIfAlreadyStarted('Cannot add route when fastify instance is already started!')
 
+    const path = opts.url || opts.path || ''
+
     if (Array.isArray(opts.method)) {
       // eslint-disable-next-line no-var
       for (var i = 0; i < opts.method.length; ++i) {
-        const method = opts.method[i]
-        if (supportedMethods.indexOf(method) === -1) {
-          throw new Error(`${method} method is not supported!`)
-        }
+        validateMethodAndSchemaBodyOption(opts.method[i], path, opts.schema)
       }
     } else {
-      if (supportedMethods.indexOf(opts.method) === -1) {
-        throw new Error(`${opts.method} method is not supported!`)
-      }
+      validateMethodAndSchemaBodyOption(opts.method, path, opts.schema)
     }
 
-    const path = opts.url || opts.path
-
     if (!opts.handler) {
       throw new Error(`Missing handler function for ${opts.method}:${path} route.`)
     }
@@ -158,42 +158,33 @@ function buildRouting (options) {
 
     const prefix = this[kRoutePrefix]
 
-    this.after((notHandledErr, done) => {
-      if (path === '/' && prefix.length && opts.method !== 'HEAD') {
-        switch (opts.prefixTrailingSlash) {
-          case 'slash':
-            afterRouteAdded.call(this, { path }, notHandledErr, done)
-            break
-          case 'no-slash':
-            afterRouteAdded.call(this, { path: '' }, notHandledErr, done)
-            break
-          case 'both':
-          default:
-            afterRouteAdded.call(this, { path: '' }, notHandledErr, done)
-            // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
-            if (ignoreTrailingSlash !== true) {
-              afterRouteAdded.call(this, { path, prefixing: true }, notHandledErr, done)
-            }
-        }
-      } else if (path && path[0] === '/' && prefix.endsWith('/')) {
-        // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
-        afterRouteAdded.call(this, { path: path.slice(1) }, notHandledErr, done)
-      } else {
-        afterRouteAdded.call(this, { path }, notHandledErr, done)
+    if (path === '/' && prefix.length > 0 && opts.method !== 'HEAD') {
+      switch (opts.prefixTrailingSlash) {
+        case 'slash':
+          addNewRoute.call(this, path)
+          break
+        case 'no-slash':
+          addNewRoute.call(this, '')
+          break
+        case 'both':
+        default:
+          addNewRoute.call(this, '')
+          // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
+          if (ignoreTrailingSlash !== true) {
+            addNewRoute.call(this, path, true)
+          }
       }
-    })
+    } else if (path[0] === '/' && prefix.endsWith('/')) {
+      // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
+      addNewRoute.call(this, path.slice(1))
+    } else {
+      addNewRoute.call(this, path)
+    }
 
     // chainable api
     return this
 
-    /**
-     * This function sets up a new route, its log serializers, and triggers route hooks.
-     *
-     * @param {object} opts contains route `path` and `prefixing` flag which indicates if this is an auto-prefixed route, e.g. `fastify.register(routes, { prefix: '/foo' })`
-     * @param {*} notHandledErr error object to be passed back to the original invoker
-     * @param {*} done callback
-     */
-    function afterRouteAdded ({ path, prefixing = false }, notHandledErr, done) {
+    function addNewRoute (path, prefixing = false) {
       const url = prefix + path
 
       opts.url = url
@@ -211,117 +202,122 @@ function buildRouting (options) {
       }
 
       if (prefixing === false) {
-      // run 'onRoute' hooks
+        // run 'onRoute' hooks
         for (const hook of this[kHooks].onRoute) {
-          try {
-            hook.call(this, opts)
-          } catch (error) {
-            done(error)
-            return
-          }
+          hook.call(this, opts)
         }
       }
 
+      const constraints = opts.constraints || {}
       const config = {
         ...opts.config,
         url,
         method: opts.method
       }
-      const constraints = opts.constraints || {}
+
+      const context = new Context({
+        schema: opts.schema,
+        handler: opts.handler.bind(this),
+        config,
+        errorHandler: opts.errorHandler,
+        bodyLimit: opts.bodyLimit,
+        logLevel: opts.logLevel,
+        logSerializers: opts.logSerializers,
+        attachValidation: opts.attachValidation,
+        schemaErrorFormatter: opts.schemaErrorFormatter,
+        replySerializer: this[kReplySerializerDefault],
+        server: this
+      })
+
       if (opts.version) {
         warning.emit('FSTDEP008')
         constraints.version = opts.version
       }
 
-      const context = new Context(
-        opts.schema,
-        opts.handler.bind(this),
-        this[kReply],
-        this[kRequest],
-        this[kContentTypeParser],
-        config,
-        opts.errorHandler || this[kErrorHandler],
-        opts.bodyLimit,
-        opts.logLevel,
-        opts.logSerializers,
-        opts.attachValidation,
-        this[kReplySerializerDefault],
-        opts.schemaErrorFormatter || this[kSchemaErrorFormatter]
-      )
+      const headRouteExists = opts.method === 'HEAD' && router.find(opts.method, opts.url, constraints) != null
 
-      const headRouteExists = router.find('HEAD', url, constraints) != null
+      // Check if the current route is not for a sibling HEAD one
+      if (!headRouteExists) {
+        try {
+          router.on(opts.method, opts.url, { constraints }, routeHandler, context)
+        } catch (error) {
+          const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route '${opts.url}'`)
+          if (isDuplicatedRoute) {
+            throw new FST_ERR_DUPLICATED_ROUTE(opts.method, opts.url)
+          }
 
-      try {
-        router.on(opts.method, opts.url, { constraints }, routeHandler, context)
-      } catch (err) {
-        done(err)
-        return
+          throw error
+        }
       }
 
-      const { exposeHeadRoute } = opts
-      const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
-      const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
+      this.after((notHandledErr, done) => {
+        // Send context async
+        context.errorHandler = opts.errorHandler ? buildErrorHandler(this[kErrorHandler], opts.errorHandler) : this[kErrorHandler]
+        context._parserOptions.limit = opts.bodyLimit || null
+        context.logLevel = opts.logLevel
+        context.logSerializers = opts.logSerializers
+        context.attachValidation = opts.attachValidation
+        context[kReplySerializerDefault] = this[kReplySerializerDefault]
+        context.schemaErrorFormatter = opts.schemaErrorFormatter || this[kSchemaErrorFormatter] || context.schemaErrorFormatter
+
+        // Run hooks and more
+        avvio.once('preReady', () => {
+          for (const hook of lifecycleHooks) {
+            const toSet = this[kHooks][hook]
+              .concat(opts[hook] || [])
+              .map(h => h.bind(this))
+            context[hook] = toSet.length ? toSet : null
+          }
 
-      if (shouldExposeHead && options.method === 'GET' && !headRouteExists) {
-        const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
-        prepareRoute.call(this, 'HEAD', path, { ...opts, onSend: onSendHandlers })
-      } else if (headRouteExists && exposeHeadRoute) {
-        warning.emit('FSTDEP007')
-      }
+          // Optimization: avoid encapsulation if no decoration has been done.
+          while (!context.Request[kHasBeenDecorated] && context.Request.parent) {
+            context.Request = context.Request.parent
+          }
+          while (!context.Reply[kHasBeenDecorated] && context.Reply.parent) {
+            context.Reply = context.Reply.parent
+          }
 
-      // It can happen that a user registers a plugin with some hooks *after*
-      // the route registration. To be sure to also load those hooks,
-      // we must listen for the avvio's preReady event, and update the context object accordingly.
-      avvio.once('preReady', () => {
-        for (const hook of lifecycleHooks) {
-          const toSet = this[kHooks][hook]
-            .concat(opts[hook] || [])
-            .map(h => {
-              const bound = h.bind(this)
-
-              // Track hooks deprecation markers
-              if (hook === 'preParsing') {
-                // Check for deprecation syntax
-                if (h.length === (h.constructor.name === 'AsyncFunction' ? 2 : 3)) {
-                  warning.emit('FSTDEP004')
-                  bound[kHooksDeprecatedPreParsing] = true
-                }
-              }
-
-              return bound
-            })
-          context[hook] = toSet.length ? toSet : null
-        }
+          // Must store the 404 Context in 'preReady' because it is only guaranteed to
+          // be available after all of the plugins and routes have been loaded.
+          fourOhFour.setContext(this, context)
 
-        // Must store the 404 Context in 'preReady' because it is only guaranteed to
-        // be available after all of the plugins and routes have been loaded.
-        fourOhFour.setContext(this, context)
+          if (opts.schema) {
+            context.schema = normalizeSchema(context.schema, this.initialConfig)
 
-        if (opts.schema) {
-          context.schema = normalizeSchema(context.schema, this.initialConfig)
+            const schemaController = this[kSchemaController]
+            if (!opts.validatorCompiler && (opts.schema.body || opts.schema.headers || opts.schema.querystring || opts.schema.params)) {
+              schemaController.setupValidator(this[kOptions])
+            }
+            try {
+              compileSchemasForValidation(context, opts.validatorCompiler || schemaController.validatorCompiler)
+            } catch (error) {
+              throw new FST_ERR_SCH_VALIDATION_BUILD(opts.method, url, error.message)
+            }
 
-          const schemaController = this[kSchemaController]
-          if (!opts.validatorCompiler && (opts.schema.body || opts.schema.headers || opts.schema.querystring || opts.schema.params)) {
-            schemaController.setupValidator(this[kOptions])
-          }
-          try {
-            compileSchemasForValidation(context, opts.validatorCompiler || schemaController.validatorCompiler)
-          } catch (error) {
-            throw new FST_ERR_SCH_VALIDATION_BUILD(opts.method, url, error.message)
+            if (opts.schema.response && !opts.serializerCompiler) {
+              schemaController.setupSerializer(this[kOptions])
+            }
+            try {
+              compileSchemasForSerialization(context, opts.serializerCompiler || schemaController.serializerCompiler)
+            } catch (error) {
+              throw new FST_ERR_SCH_SERIALIZATION_BUILD(opts.method, url, error.message)
+            }
           }
+        })
 
-          if (opts.schema.response && !opts.serializerCompiler) {
-            schemaController.setupSerializer(this[kOptions])
-          }
-          try {
-            compileSchemasForSerialization(context, opts.serializerCompiler || schemaController.serializerCompiler)
-          } catch (error) {
-            throw new FST_ERR_SCH_SERIALIZATION_BUILD(opts.method, url, error.message)
-          }
+        const { exposeHeadRoute } = opts
+        const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
+        const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
+
+        if (shouldExposeHead && options.method === 'GET' && !headRouteExists) {
+          const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
+          prepareRoute.call(this, 'HEAD', path, { ...opts, onSend: onSendHandlers })
+        } else if (headRouteExists && exposeHeadRoute) {
+          warning.emit('FSTDEP007')
         }
-      })
 
-      done(notHandledErr)
+        done(notHandledErr)
+      })
     }
   }
 
@@ -345,6 +341,17 @@ function buildRouting (options) {
       }
     }
 
+    // When server.forceCloseConnections is true, we will collect any requests
+    // that have indicated they want persistence so that they can be reaped
+    // on server close. Otherwise, the container is a noop container.
+    const connHeader = String.prototype.toLowerCase.call(req.headers.connection || '')
+    if (connHeader === 'keep-alive') {
+      if (keepAliveConnections.has(req.socket) === false) {
+        keepAliveConnections.add(req.socket)
+        req.socket.on('close', removeTrackedSocket.bind({ keepAliveConnections, socket: req.socket }))
+      }
+    }
+
     // we revert the changes in defaultRoute
     if (req.headers[kRequestAcceptVersion] !== undefined) {
       req.headers['accept-version'] = req.headers[kRequestAcceptVersion]
@@ -412,6 +419,16 @@ function handleTimeout () {
   )
 }
 
+function validateMethodAndSchemaBodyOption (method, path, schema) {
+  if (supportedMethods.indexOf(method) === -1) {
+    throw new Error(`${method} method is not supported!`)
+  }
+
+  if ((method === 'GET' || method === 'HEAD') && schema && schema.body) {
+    throw new Error(`Body validation schema for ${method}:${path} route is not supported!`)
+  }
+}
+
 function validateBodyLimitOption (bodyLimit) {
   if (bodyLimit === undefined) return
   if (!Number.isInteger(bodyLimit) || bodyLimit <= 0) {
@@ -422,6 +439,7 @@ function validateBodyLimitOption (bodyLimit) {
 function runPreParsing (err, request, reply) {
   if (reply.sent === true) return
   if (err != null) {
+    reply[kReplyIsError] = true
     reply.send(err)
     return
   }
@@ -448,10 +466,6 @@ function preParsingHookRunner (functions, request, reply, cb) {
     }
 
     if (err || i === functions.length) {
-      if (err && !(err instanceof Error)) {
-        reply[kReplyIsError] = true
-      }
-
       cb(err, request, reply)
       return
     }
@@ -459,11 +473,7 @@ function preParsingHookRunner (functions, request, reply, cb) {
     const fn = functions[i++]
     let result
     try {
-      if (fn[kHooksDeprecatedPreParsing]) {
-        result = fn(request, reply, next)
-      } else {
-        result = fn(request, reply, request[kRequestPayloadStream], next)
-      }
+      result = fn(request, reply, request[kRequestPayloadStream], next)
     } catch (error) {
       next(error)
       return
@@ -485,6 +495,15 @@ function preParsingHookRunner (functions, request, reply, cb) {
   next(null, request[kRequestPayloadStream])
 }
 
+/**
+ * Used within the route handler as a `net.Socket.close` event handler.
+ * The purpose is to remove a socket from the tracked sockets collection when
+ * the socket has naturally timed out.
+ */
+function removeTrackedSocket () {
+  this.keepAliveConnections.delete(this.socket)
+}
+
 function noop () { }
 
 module.exports = { buildRouting, validateBodyLimitOption }

package/lib/schema-controller.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { buildSchemas } = require('./schemas')
-const { serializerCompiler } = require('./schema-compilers')
+const SerializerSelector = require('@fastify/fast-json-stringify-compiler')
 const ValidatorSelector = require('@fastify/ajv-compiler')
 
 /**
@@ -17,7 +17,7 @@ function buildSchemaController (parentSchemaCtrl, opts) {
 
   let compilersFactory = {
     buildValidator: ValidatorSelector(),
-    buildSerializer: serializerCompiler
+    buildSerializer: SerializerSelector()
   }
   if (opts && opts.compilersFactory) {
     compilersFactory = Object.assign(compilersFactory, opts.compilersFactory)
@@ -25,7 +25,7 @@ function buildSchemaController (parentSchemaCtrl, opts) {
 
   const option = {
     bucket: (opts && opts.bucket) || buildSchemas,
-    compilersFactory: compilersFactory
+    compilersFactory
   }
 
   return new SchemaController(undefined, option)

package/lib/schemas.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const fastClone = require('rfdc')({ circles: false, proto: true })
-const { kSchemaVisited } = require('./symbols')
+const { kSchemaVisited, kSchemaResponse } = require('./symbols')
 const kFluentSchema = Symbol.for('fluent-schema-object')
 
 const {
@@ -121,7 +121,33 @@ function getSchemaAnyway (schema, jsonShorthand) {
   return schema
 }
 
+/**
+ * Search for the right JSON schema compiled function in the request context
+ * setup by the route configuration `schema.response`.
+ * It will look for the exact match (eg 200) or generic (eg 2xx)
+ *
+ * @param {object} context the request context
+ * @param {number} statusCode the http status code
+ * @returns {function|boolean} the right JSON Schema function to serialize
+ * the reply or false if it is not set
+ */
+function getSchemaSerializer (context, statusCode) {
+  const responseSchemaDef = context[kSchemaResponse]
+  if (!responseSchemaDef) {
+    return false
+  }
+  if (responseSchemaDef[statusCode]) {
+    return responseSchemaDef[statusCode]
+  }
+  const fallbackStatusCode = (statusCode + '')[0] + 'xx'
+  if (responseSchemaDef[fallbackStatusCode]) {
+    return responseSchemaDef[fallbackStatusCode]
+  }
+  return false
+}
+
 module.exports = {
   buildSchemas (initStore) { return new Schemas(initStore) },
+  getSchemaSerializer,
   normalizeSchema
 }