fastify 5.0.0-alpha.2 → 5.0.0-alpha.4

package/lib/reply.js

@@ -5,7 +5,6 @@ const Readable = require('node:stream').Readable
 
 const {
   kFourOhFourContext,
-  kPublicRouteContext,
   kReplyErrorHandlerCalled,
   kReplyHijacked,
   kReplyStartTime,
@@ -47,7 +46,6 @@ const {
   FST_ERR_REP_INVALID_PAYLOAD_TYPE,
   FST_ERR_REP_RESPONSE_BODY_CONSUMED,
   FST_ERR_REP_ALREADY_SENT,
-  FST_ERR_REP_SENT_VALUE,
   FST_ERR_SEND_INSIDE_ONERR,
   FST_ERR_BAD_STATUS_CODE,
   FST_ERR_BAD_TRAILER_NAME,
@@ -55,7 +53,6 @@ const {
   FST_ERR_MISSING_SERIALIZATION_FN,
   FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN
 } = require('./errors')
-const { FSTDEP010, FSTDEP013, FSTDEP019, FSTDEP021 } = require('./warnings')
 
 const toString = Object.prototype.toString
 
@@ -80,14 +77,6 @@ Object.defineProperties(Reply.prototype, {
       return this.request[kRouteContext]
     }
   },
-  // TODO: remove once v5 is done
-  // Is temporary to avoid constant conflicts between `next` and `main`
-  context: {
-    get () {
-      FSTDEP019()
-      return this.request[kRouteContext]
-    }
-  },
   elapsedTime: {
     get () {
       if (this[kReplyStartTime] === undefined) {
@@ -106,20 +95,6 @@ Object.defineProperties(Reply.prototype, {
     get () {
       // We are checking whether reply was hijacked or the response has ended.
       return (this[kReplyHijacked] || this.raw.writableEnded) === true
-    },
-    set (value) {
-      FSTDEP010()
-
-      if (value !== true) {
-        throw new FST_ERR_REP_SENT_VALUE()
-      }
-
-      // We throw only if sent was overwritten from Fastify
-      if (this.sent && this[kReplyHijacked]) {
-        throw new FST_ERR_REP_ALREADY_SENT(this.request.url, this.request.method)
-      }
-
-      this[kReplyHijacked] = true
     }
   },
   statusCode: {
@@ -130,9 +105,9 @@ Object.defineProperties(Reply.prototype, {
       this.code(value)
     }
   },
-  [kPublicRouteContext]: {
+  routeOptions: {
     get () {
-      return this.request[kPublicRouteContext]
+      return this.request.routeOptions
     }
   }
 })
@@ -208,7 +183,7 @@ Reply.prototype.send = function (payload) {
       payload = this[kReplySerializer](payload)
     }
 
-  // The indexOf below also matches custom json mimetypes such as 'application/hal+json' or 'application/ld+json'
+    // The indexOf below also matches custom json mimetypes such as 'application/hal+json' or 'application/ld+json'
   } else if (hasContentType === false || contentType.indexOf('json') > -1) {
     if (hasContentType === false) {
       this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
@@ -376,13 +351,13 @@ Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null
   }
 
   const serializerCompiler = this[kRouteContext].serializerCompiler ||
-   this.server[kSchemaController].serializerCompiler ||
-  (
-    // We compile the schemas if no custom serializerCompiler is provided
-    // nor set
-    this.server[kSchemaController].setupSerializer(this.server[kOptions]) ||
-    this.server[kSchemaController].serializerCompiler
-  )
+    this.server[kSchemaController].serializerCompiler ||
+    (
+      // We compile the schemas if no custom serializerCompiler is provided
+      // nor set
+      this.server[kSchemaController].setupSerializer(this.server[kOptions]) ||
+      this.server[kSchemaController].serializerCompiler
+    )
 
   const serializeFn = serializerCompiler({
     schema,
@@ -463,13 +438,6 @@ Reply.prototype.type = function (type) {
 }
 
 Reply.prototype.redirect = function (url, code) {
-  if (typeof url === 'number') {
-    FSTDEP021()
-    const temp = code
-    code = url
-    url = temp
-  }
-
   if (!code) {
     code = this[kReplyHasStatusCode] ? this.raw.statusCode : 302
   }
@@ -600,14 +568,30 @@ function onSendEnd (reply, payload) {
     reply.header('Trailer', header.trim())
   }
 
-  // since Response contain status code, we need to update before
-  // any action that used statusCode
-  const isResponse = toString.call(payload) === '[object Response]'
-  if (isResponse) {
+  // since Response contain status code, headers and body,
+  // we need to update the status, add the headers and use it's body as payload
+  // before continuing
+  if (toString.call(payload) === '[object Response]') {
     // https://developer.mozilla.org/en-US/docs/Web/API/Response/status
     if (typeof payload.status === 'number') {
       reply.code(payload.status)
     }
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Response/headers
+    if (typeof payload.headers === 'object' && typeof payload.headers.forEach === 'function') {
+      for (const [headerName, headerValue] of payload.headers) {
+        reply.header(headerName, headerValue)
+      }
+    }
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Response/body
+    if (payload.body !== null) {
+      if (payload.bodyUsed) {
+        throw new FST_ERR_REP_RESPONSE_BODY_CONSUMED()
+      }
+    }
+    // Keep going, body is either null or ReadableStream
+    payload = payload.body
   }
   const statusCode = res.statusCode
 
@@ -654,26 +638,6 @@ function onSendEnd (reply, payload) {
     return
   }
 
-  // Response
-  if (isResponse) {
-    // https://developer.mozilla.org/en-US/docs/Web/API/Response/headers
-    if (typeof payload.headers === 'object' && typeof payload.headers.forEach === 'function') {
-      for (const [headerName, headerValue] of payload.headers) {
-        reply.header(headerName, headerValue)
-      }
-    }
-
-    // https://developer.mozilla.org/en-US/docs/Web/API/Response/body
-    if (payload.body != null) {
-      if (payload.bodyUsed) {
-        throw new FST_ERR_REP_RESPONSE_BODY_CONSUMED()
-      }
-      // Response.body always a ReadableStream
-      sendWebStream(payload.body, res, reply)
-    }
-    return
-  }
-
   if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {
     throw new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload)
   }
@@ -681,9 +645,9 @@ function onSendEnd (reply, payload) {
   if (reply[kReplyTrailers] === null) {
     const contentLength = reply[kReplyHeaders]['content-length']
     if (!contentLength ||
-        (req.raw.method !== 'HEAD' &&
-         Number(contentLength) !== Buffer.byteLength(payload)
-        )
+      (req.raw.method !== 'HEAD' &&
+        Number(contentLength) !== Buffer.byteLength(payload)
+      )
     ) {
       reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
     }
@@ -724,7 +688,7 @@ function sendStream (payload, res, reply) {
       if (res.headersSent || reply.request.raw.aborted === true) {
         if (!errorLogged) {
           errorLogged = true
-          logStreamError(reply.log, err, res)
+          logStreamError(reply.log, err, reply)
         }
         res.destroy()
       } else {
@@ -812,10 +776,6 @@ function sendTrailer (payload, res, reply) {
     const result = reply[kReplyTrailers][trailerName](reply, payload, cb)
     if (typeof result === 'object' && typeof result.then === 'function') {
       result.then((v) => cb(null, v), cb)
-    } else if (result !== null && result !== undefined) {
-      // TODO: should be removed in fastify@5
-      FSTDEP013()
-      cb(null, result)
     }
   }
 

package/lib/request.js

@@ -1,14 +1,6 @@
 'use strict'
 
 const proxyAddr = require('proxy-addr')
-const {
-  FSTDEP005,
-  FSTDEP012,
-  FSTDEP015,
-  FSTDEP016,
-  FSTDEP017,
-  FSTDEP018
-} = require('./warnings')
 const {
   kHasBeenDecorated,
   kSchemaBody,
@@ -19,7 +11,6 @@ const {
   kOptions,
   kRequestCacheValidateFns,
   kRouteContext,
-  kPublicRouteContext,
   kRequestOriginalUrl
 } = require('./symbols')
 const { FST_ERR_REQ_INVALID_VALIDATION_INVOCATION } = require('./errors')
@@ -171,18 +162,6 @@ Object.defineProperties(Request.prototype, {
       return this.raw.method
     }
   },
-  context: {
-    get () {
-      FSTDEP012()
-      return this[kRouteContext]
-    }
-  },
-  routerPath: {
-    get () {
-      FSTDEP017()
-      return this[kRouteContext].config?.url
-    }
-  },
   routeOptions: {
     get () {
       const context = this[kRouteContext]
@@ -213,35 +192,11 @@ Object.defineProperties(Request.prototype, {
       return Object.freeze(options)
     }
   },
-  routerMethod: {
-    get () {
-      FSTDEP018()
-      return this[kRouteContext].config?.method
-    }
-  },
-  routeConfig: {
-    get () {
-      FSTDEP016()
-      return this[kRouteContext][kPublicRouteContext]?.config
-    }
-  },
-  routeSchema: {
-    get () {
-      FSTDEP015()
-      return this[kRouteContext][kPublicRouteContext].schema
-    }
-  },
   is404: {
     get () {
       return this[kRouteContext].config?.url === undefined
     }
   },
-  connection: {
-    get () {
-      FSTDEP005()
-      return this.raw.connection
-    }
-  },
   socket: {
     get () {
       return this.raw.socket

package/lib/route.js

@@ -4,13 +4,8 @@ const FindMyWay = require('find-my-way')
 const Context = require('./context')
 const handleRequest = require('./handleRequest')
 const { onRequestAbortHookRunner, lifecycleHooks, preParsingHookRunner, onTimeoutHookRunner, onRequestHookRunner } = require('./hooks')
-const { supportedMethods } = require('./httpMethods')
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
-const {
-  FSTDEP007,
-  FSTDEP008
-} = require('./warnings')
 
 const {
   compileSchemasForValidation,
@@ -36,6 +31,7 @@ const {
 
 const {
   kRoutePrefix,
+  kSupportedHTTPMethods,
   kLogLevel,
   kLogSerializers,
   kHooks,
@@ -91,7 +87,7 @@ function buildRouting (options) {
       disableRequestLogging = options.disableRequestLogging
       ignoreTrailingSlash = options.ignoreTrailingSlash
       ignoreDuplicateSlashes = options.ignoreDuplicateSlashes
-      return503OnClosing = Object.prototype.hasOwnProperty.call(options, 'return503OnClosing') ? options.return503OnClosing : true
+      return503OnClosing = Object.hasOwn(options, 'return503OnClosing') ? options.return503OnClosing : true
       keepAliveConnections = fastifyArgs.keepAliveConnections
     },
     routing: router.lookup.bind(router), // router func to find the right handler to call
@@ -207,12 +203,12 @@ function buildRouting (options) {
     if (Array.isArray(opts.method)) {
       // eslint-disable-next-line no-var
       for (var i = 0; i < opts.method.length; ++i) {
-        opts.method[i] = normalizeAndValidateMethod(opts.method[i])
-        validateSchemaBodyOption(opts.method[i], path, opts.schema)
+        opts.method[i] = normalizeAndValidateMethod.call(this, opts.method[i])
+        validateSchemaBodyOption.call(this, opts.method[i], path, opts.schema)
       }
     } else {
-      opts.method = normalizeAndValidateMethod(opts.method)
-      validateSchemaBodyOption(opts.method, path, opts.schema)
+      opts.method = normalizeAndValidateMethod.call(this, opts.method)
+      validateSchemaBodyOption.call(this, opts.method, path, opts.schema)
     }
 
     if (!opts.handler) {
@@ -332,26 +328,16 @@ function buildRouting (options) {
         isFastify
       })
 
-      if (opts.version) {
-        FSTDEP008()
-        constraints.version = opts.version
-      }
-
       const headHandler = router.findRoute('HEAD', opts.url, constraints)
       const hasHEADHandler = headHandler !== null
 
-      // remove the head route created by fastify
-      if (isHeadRoute && hasHEADHandler && !context[kRouteByFastify] && headHandler.store[kRouteByFastify]) {
-        router.off('HEAD', opts.url, constraints)
-      }
-
       try {
         router.on(opts.method, opts.url, { constraints }, routeHandler, context)
       } catch (error) {
         // any route insertion error created by fastify can be safely ignore
         // because it only duplicate route for head
         if (!context[kRouteByFastify]) {
-          const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route '${opts.url}'`)
+          const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route`)
           if (isDuplicatedRoute) {
             throw new FST_ERR_DUPLICATED_ROUTE(opts.method, opts.url)
           }
@@ -425,8 +411,6 @@ function buildRouting (options) {
       if (shouldExposeHead && isGetRoute && !isHeadRoute && !hasHEADHandler) {
         const onSendHandlers = parseHeadOnSendHandlers(headOpts.onSend)
         prepareRoute.call(this, { method: 'HEAD', url: path, options: { ...headOpts, onSend: onSendHandlers }, isFastify: true })
-      } else if (hasHEADHandler && exposeHeadRoute) {
-        FSTDEP007()
       }
     }
   }
@@ -549,7 +533,8 @@ function normalizeAndValidateMethod (method) {
     throw new FST_ERR_ROUTE_METHOD_INVALID()
   }
   method = method.toUpperCase()
-  if (supportedMethods.indexOf(method) === -1) {
+  if (!this[kSupportedHTTPMethods].bodyless.has(method) &&
+    !this[kSupportedHTTPMethods].bodywith.has(method)) {
     throw new FST_ERR_ROUTE_METHOD_NOT_SUPPORTED(method)
   }
 
@@ -557,7 +542,7 @@ function normalizeAndValidateMethod (method) {
 }
 
 function validateSchemaBodyOption (method, path, schema) {
-  if ((method === 'GET' || method === 'HEAD') && schema && schema.body) {
+  if (this[kSupportedHTTPMethods].bodyless.has(method) && schema?.body) {
     throw new FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED(method, path)
   }
 }
@@ -580,9 +565,9 @@ function runPreParsing (err, request, reply) {
   request[kRequestPayloadStream] = request.raw
 
   if (request[kRouteContext].preParsing !== null) {
-    preParsingHookRunner(request[kRouteContext].preParsing, request, reply, handleRequest)
+    preParsingHookRunner(request[kRouteContext].preParsing, request, reply, handleRequest.bind(request.server))
   } else {
-    handleRequest(null, request, reply)
+    handleRequest.call(request.server, null, request, reply)
   }
 }
 

package/lib/schemas.js

@@ -73,7 +73,18 @@ function normalizeSchema (routeSchemas, serverOptions) {
   for (const key of SCHEMAS_SOURCE) {
     const schema = routeSchemas[key]
     if (schema && !isCustomSchemaPrototype(schema)) {
-      routeSchemas[key] = getSchemaAnyway(schema, serverOptions.jsonShorthand)
+      if (key === 'body' && schema.content) {
+        const contentProperty = schema.content
+        const keys = Object.keys(contentProperty)
+        for (let i = 0; i < keys.length; i++) {
+          const contentType = keys[i]
+          const contentSchema = contentProperty[contentType].schema
+          if (!contentSchema) {
+            throw new FST_ERR_SCH_CONTENT_MISSING_SCHEMA(contentType)
+          }
+        }
+        continue
+      }
     }
   }
 
@@ -86,25 +97,15 @@ function normalizeSchema (routeSchemas, serverOptions) {
 
       const contentProperty = routeSchemas.response[code].content
 
-      let hasContentMultipleContentTypes = false
       if (contentProperty) {
         const keys = Object.keys(contentProperty)
         for (let i = 0; i < keys.length; i++) {
           const mediaName = keys[i]
           if (!contentProperty[mediaName].schema) {
-            if (keys.length === 1) { break }
             throw new FST_ERR_SCH_CONTENT_MISSING_SCHEMA(mediaName)
           }
-          routeSchemas.response[code].content[mediaName].schema = getSchemaAnyway(contentProperty[mediaName].schema, serverOptions.jsonShorthand)
-          if (i === keys.length - 1) {
-            hasContentMultipleContentTypes = true
-          }
         }
       }
-
-      if (!hasContentMultipleContentTypes) {
-        routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code], serverOptions.jsonShorthand)
-      }
     }
   }
 
@@ -129,17 +130,6 @@ function generateFluentSchema (schema) {
   }
 }
 
-function getSchemaAnyway (schema, jsonShorthand) {
-  if (!jsonShorthand || schema.$ref || schema.oneOf || schema.allOf || schema.anyOf || schema.$merge || schema.$patch) return schema
-  if (!schema.type && !schema.properties) {
-    return {
-      type: 'object',
-      properties: schema
-    }
-  }
-  return schema
-}
-
 /**
  * Search for the right JSON schema compiled function in the request context
  * setup by the route configuration `schema.response`.
@@ -163,6 +153,11 @@ function getSchemaSerializer (context, statusCode, contentType) {
         return responseSchemaDef[statusCode][mediaName]
       }
 
+      // fallback to match all media-type
+      if (responseSchemaDef[statusCode]['*/*']) {
+        return responseSchemaDef[statusCode]['*/*']
+      }
+
       return false
     }
     return responseSchemaDef[statusCode]
@@ -175,6 +170,11 @@ function getSchemaSerializer (context, statusCode, contentType) {
         return responseSchemaDef[fallbackStatusCode][mediaName]
       }
 
+      // fallback to match all media-type
+      if (responseSchemaDef[fallbackStatusCode]['*/*']) {
+        return responseSchemaDef[fallbackStatusCode]['*/*']
+      }
+
       return false
     }
 
@@ -187,6 +187,11 @@ function getSchemaSerializer (context, statusCode, contentType) {
         return responseSchemaDef.default[mediaName]
       }
 
+      // fallback to match all media-type
+      if (responseSchemaDef.default['*/*']) {
+        return responseSchemaDef.default['*/*']
+      }
+
       return false
     }
 

package/lib/server.js

@@ -55,7 +55,8 @@ function createServer (options, httpHandler) {
     } else {
       host = listenOptions.host
     }
-    if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
+    if (!Object.hasOwn(listenOptions, 'host') ||
+      listenOptions.host == null) {
       listenOptions.host = host
     }
     if (host === 'localhost') {
@@ -143,7 +144,6 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
             cb: (_ignoreErr) => {
               bound++
 
-              /* istanbul ignore next: the else won't be taken unless listening fails */
               if (!_ignoreErr) {
                 this[kServerBindings].push(secondaryServer)
               }
@@ -157,18 +157,13 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
 
           const secondaryServer = getServerInstance(serverOpts, httpHandler)
           const closeSecondary = () => {
-            // To avoid fall into situations where the close of the
+            // To avoid falling into situations where the close of the
             // secondary server is triggered before the preClose hook
-            // is done running, we better wait until the main server
-            // is closed.
+            // is done running, we better wait until the main server is closed.
             // No new TCP connections are accepted
-            // We swallow any error from the secondary
-            // server
+            // We swallow any error from the secondary server
             secondaryServer.close(() => {})
-            if (serverOpts.forceCloseConnections === 'idle') {
-              // Not needed in Node 19
-              secondaryServer.closeIdleConnections()
-            } else if (typeof secondaryServer.closeAllConnections === 'function' && serverOpts.forceCloseConnections) {
+            if (typeof secondaryServer.closeAllConnections === 'function' && serverOpts.forceCloseConnections === true) {
               secondaryServer.closeAllConnections()
             }
           }

package/lib/symbols.js

@@ -5,6 +5,7 @@ const keys = {
   kChildren: Symbol('fastify.children'),
   kServerBindings: Symbol('fastify.serverBindings'),
   kBodyLimit: Symbol('fastify.bodyLimit'),
+  kSupportedHTTPMethods: Symbol('fastify.acceptedHTTPMethods'),
   kRoutePrefix: Symbol('fastify.routePrefix'),
   kLogLevel: Symbol('fastify.logLevel'),
   kLogSerializers: Symbol('fastify.logSerializers'),
@@ -15,7 +16,6 @@ const keys = {
   kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
   kPluginNameChain: Symbol('fastify.pluginNameChain'),
   kRouteContext: Symbol('fastify.context'),
-  kPublicRouteContext: Symbol('fastify.routeOptions'),
   kGenReqId: Symbol('fastify.genReqId'),
   // Schema
   kSchemaController: Symbol('fastify.schemaController'),

package/lib/validation.js

@@ -82,25 +82,35 @@ function compileSchemasForValidation (context, compile, isCustom) {
       })
     }
     context[headersSchema] = compile({ schema: headersSchemaLowerCase, method, url, httpPart: 'headers' })
-  } else if (Object.prototype.hasOwnProperty.call(schema, 'headers')) {
+  } else if (Object.hasOwn(schema, 'headers')) {
     FSTWRN001('headers', method, url)
   }
 
   if (schema.body) {
-    context[bodySchema] = compile({ schema: schema.body, method, url, httpPart: 'body' })
-  } else if (Object.prototype.hasOwnProperty.call(schema, 'body')) {
+    const contentProperty = schema.body.content
+    if (contentProperty) {
+      const contentTypeSchemas = {}
+      for (const contentType of Object.keys(contentProperty)) {
+        const contentSchema = contentProperty[contentType].schema
+        contentTypeSchemas[contentType] = compile({ schema: contentSchema, method, url, httpPart: 'body', contentType })
+      }
+      context[bodySchema] = contentTypeSchemas
+    } else {
+      context[bodySchema] = compile({ schema: schema.body, method, url, httpPart: 'body' })
+    }
+  } else if (Object.hasOwn(schema, 'body')) {
     FSTWRN001('body', method, url)
   }
 
   if (schema.querystring) {
     context[querystringSchema] = compile({ schema: schema.querystring, method, url, httpPart: 'querystring' })
-  } else if (Object.prototype.hasOwnProperty.call(schema, 'querystring')) {
+  } else if (Object.hasOwn(schema, 'querystring')) {
     FSTWRN001('querystring', method, url)
   }
 
   if (schema.params) {
     context[paramsSchema] = compile({ schema: schema.params, method, url, httpPart: 'params' })
-  } else if (Object.prototype.hasOwnProperty.call(schema, 'params')) {
+  } else if (Object.hasOwn(schema, 'params')) {
     FSTWRN001('params', method, url)
   }
 }
@@ -140,7 +150,18 @@ function validate (context, request, execution) {
   }
 
   if (runExecution || !execution.skipBody) {
-    const body = validateParam(context[bodySchema], request, 'body')
+    let validatorFunction = null
+    if (typeof context[bodySchema] === 'function') {
+      validatorFunction = context[bodySchema]
+    } else if (context[bodySchema]) {
+      // TODO: add request.contentType and reuse it here
+      const contentType = request.headers['content-type']?.split(';', 1)[0]
+      const contentSchema = context[bodySchema][contentType]
+      if (contentSchema) {
+        validatorFunction = contentSchema
+      }
+    }
+    const body = validateParam(validatorFunction, request, 'body')
     if (body) {
       if (typeof body.then !== 'function') {
         return wrapValidationError(body, 'body', context.schemaErrorFormatter)