fastify 3.27.4 → 4.0.0-alpha.3

package/lib/server.js

@@ -1,16 +1,214 @@
 'use strict'
 
-const assert = require('assert')
 const http = require('http')
 const https = require('https')
+const dns = require('dns')
 
-const { kState, kOptions } = require('./symbols')
+const warnings = require('./warnings')
+const { kState, kOptions, kServerBindings } = require('./symbols')
 const { FST_ERR_HTTP2_INVALID_VERSION, FST_ERR_REOPENED_CLOSE_SERVER, FST_ERR_REOPENED_SERVER } = require('./errors')
 
+module.exports = createServer
+
 function createServer (options, httpHandler) {
-  assert(options, 'Missing options')
-  assert(httpHandler, 'Missing http handler')
+  const server = getServerInstance(options, httpHandler)
+
+  return { server, listen }
+
+  // `this` is the Fastify object
+  function listen (listenOptions, ...args) {
+    let cb = args.slice(-1).pop()
+    // When the variadic signature deprecation is complete, the function
+    // declaration should become:
+    //   function listen (listenOptions = { port: 0, host: 'localhost' }, cb = undefined)
+    // Upon doing so, the `normalizeListenArgs` function is no longer needed,
+    // and all of this preamble to feed it correctly also no longer needed.
+    const firstArgType = Object.prototype.toString.call(arguments[0])
+    if (arguments.length === 0) {
+      listenOptions = normalizeListenArgs([])
+    } else if (arguments.length > 0 && (firstArgType !== '[object Object]' && firstArgType !== '[object Function]')) {
+      warnings.emit('FSTDEP011')
+      listenOptions = normalizeListenArgs(Array.from(arguments))
+      cb = listenOptions.cb
+    } else if (args.length > 1) {
+      // `.listen(obj, a, ..., n, callback )`
+      warnings.emit('FSTDEP011')
+      // Deal with `.listen(port, host, backlog, [cb])`
+      const hostPath = listenOptions.path ? [listenOptions.path] : [listenOptions.port ?? 0, listenOptions.host ?? 'localhost']
+      Object.assign(listenOptions, normalizeListenArgs([...hostPath, ...args]))
+    } else {
+      listenOptions.cb = cb
+    }
+
+    const { host = 'localhost' } = listenOptions
+    if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
+      listenOptions.host = host
+    }
+
+    if (host === 'localhost') {
+      listenOptions.cb = (err, address) => {
+        if (err) {
+          // the server did not start
+          cb(err, address)
+          return
+        }
+
+        multipleBindings.call(this, server, httpHandler, options, listenOptions, () => {
+          this[kState].listening = true
+          cb(null, address)
+        })
+      }
+    }
+
+    // https://github.com/nodejs/node/issues/9390
+    // If listening to 'localhost', listen to both 127.0.0.1 or ::1 if they are available.
+    // If listening to 127.0.0.1, only listen to 127.0.0.1.
+    // If listening to ::1, only listen to ::1.
+
+    if (cb === undefined) {
+      const listening = listenPromise.call(this, server, listenOptions)
+      /* istanbul ignore else */
+      if (host === 'localhost') {
+        return listening.then(address => {
+          return new Promise((resolve, reject) => {
+            multipleBindings.call(this, server, httpHandler, options, listenOptions, () => {
+              this[kState].listening = true
+              resolve(address)
+            })
+          })
+        })
+      }
+      return listening
+    }
+
+    this.ready(listenCallback.call(this, server, listenOptions))
+  }
+}
+
+function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, onListen) {
+  // the main server is started, we need to start the secondary servers
+  this[kState].listening = false
+
+  // let's check if we need to bind additional addresses
+  dns.lookup(listenOptions.host, { all: true }, (dnsErr, addresses) => {
+    if (dnsErr) {
+      // not blocking the main server listening
+      // this.log.warn('dns.lookup error:', dnsErr)
+      onListen()
+      return
+    }
+
+    let binding = 0
+    let binded = 0
+    const primaryAddress = mainServer.address()
+    for (const adr of addresses) {
+      if (adr.address !== primaryAddress.address) {
+        binding++
+        const secondaryOpts = Object.assign({}, listenOptions, {
+          host: adr.address,
+          port: primaryAddress.port,
+          cb: (_ignoreErr) => {
+            binded++
+
+            if (!_ignoreErr) {
+              this[kServerBindings].push(secondaryServer)
+            }
+
+            if (binded === binding) {
+              // regardless of the error, we are done
+              onListen()
+            }
+          }
+        })
+
+        const secondaryServer = getServerInstance(serverOpts, httpHandler)
+        const closeSecondary = () => { secondaryServer.close(() => {}) }
+        mainServer.on('unref', closeSecondary)
+        mainServer.on('close', closeSecondary)
+        mainServer.on('error', closeSecondary)
+        listenCallback.call(this, secondaryServer, secondaryOpts)()
+      }
+    }
+
+    // no extra bindings are necessary
+    if (binding === 0) {
+      onListen()
+      return
+    }
+
+    // in test files we are using unref so we need to propagate the unref event
+    // to the secondary servers. It is valid only when the user is
+    // listening on localhost
+    const originUnref = mainServer.unref
+    /* istanbul ignore next */
+    mainServer.unref = function () {
+      originUnref.call(mainServer)
+      mainServer.emit('unref')
+    }
+  })
+}
+
+function listenCallback (server, listenOptions) {
+  const wrap = (err) => {
+    server.removeListener('error', wrap)
+    if (!err) {
+      const address = logServerAddress.call(this, server)
+      listenOptions.cb(null, address)
+    } else {
+      this[kState].listening = false
+      listenOptions.cb(err, null)
+    }
+  }
+
+  return (err) => {
+    if (err != null) return listenOptions.cb(err)
+
+    if (this[kState].listening && this[kState].closing) {
+      return listenOptions.cb(new FST_ERR_REOPENED_CLOSE_SERVER(), null)
+    } else if (this[kState].listening) {
+      return listenOptions.cb(new FST_ERR_REOPENED_SERVER(), null)
+    }
+
+    server.once('error', wrap)
+    server.listen(listenOptions, wrap)
+
+    this[kState].listening = true
+  }
+}
+
+function listenPromise (server, listenOptions) {
+  if (this[kState].listening && this[kState].closing) {
+    return Promise.reject(new FST_ERR_REOPENED_CLOSE_SERVER())
+  } else if (this[kState].listening) {
+    return Promise.reject(new FST_ERR_REOPENED_SERVER())
+  }
 
+  return this.ready().then(() => {
+    let errEventHandler
+    const errEvent = new Promise((resolve, reject) => {
+      errEventHandler = (err) => {
+        this[kState].listening = false
+        reject(err)
+      }
+      server.once('error', errEventHandler)
+    })
+    const listen = new Promise((resolve, reject) => {
+      server.listen(listenOptions, () => {
+        server.removeListener('error', errEventHandler)
+        resolve(logServerAddress.call(this, server))
+      })
+      // we set it afterwards because listen can throw
+      this[kState].listening = true
+    })
+
+    return Promise.race([
+      errEvent, // e.g invalid port range error is always emitted before the server listening
+      listen
+    ])
+  })
+}
+
+function getServerInstance (options, httpHandler) {
   let server = null
   if (options.serverFactory) {
     server = options.serverFactory(httpHandler, options)
@@ -41,123 +239,53 @@ function createServer (options, httpHandler) {
   if (!options.serverFactory) {
     server.setTimeout(options.connectionTimeout)
   }
+  return server
+}
 
-  return { server, listen }
-
-  // `this` is the Fastify object
-  function listen () {
-    const normalizeListenArgs = (args) => {
-      if (args.length === 0) {
-        return { port: 0, host: 'localhost' }
-      }
-
-      const cb = typeof args[args.length - 1] === 'function' ? args.pop() : undefined
-      const options = { cb }
-
-      const firstArg = args[0]
-      const argsLength = args.length
-      const lastArg = args[argsLength - 1]
-      /* Deal with listen (options) || (handle[, backlog]) */
-      if (typeof firstArg === 'object' && firstArg !== null) {
-        options.backlog = argsLength > 1 ? lastArg : undefined
-        Object.assign(options, firstArg)
-      } else if (typeof firstArg === 'string' && isNaN(firstArg)) {
-        /* Deal with listen (pipe[, backlog]) */
-        options.path = firstArg
-        options.backlog = argsLength > 1 ? lastArg : undefined
-      } else {
-        /* Deal with listen ([port[, host[, backlog]]]) */
-        options.port = argsLength >= 1 && firstArg ? firstArg : 0
-        // This will listen to what localhost is.
-        // It can be 127.0.0.1 or ::1, depending on the operating system.
-        // Fixes https://github.com/fastify/fastify/issues/1022.
-        options.host = argsLength >= 2 && args[1] ? args[1] : 'localhost'
-        options.backlog = argsLength >= 3 ? args[2] : undefined
-      }
-
-      return options
-    }
-
-    const listenOptions = normalizeListenArgs(Array.from(arguments))
-    const cb = listenOptions.cb
-
-    const wrap = err => {
-      server.removeListener('error', wrap)
-      if (!err) {
-        const address = logServerAddress()
-        cb(null, address)
-      } else {
-        this[kState].listening = false
-        cb(err, null)
-      }
-    }
+function normalizeListenArgs (args) {
+  if (args.length === 0) {
+    return { port: 0, host: 'localhost' }
+  }
 
-    const listenPromise = (listenOptions) => {
-      if (this[kState].listening && this[kState].closing) {
-        return Promise.reject(new FST_ERR_REOPENED_CLOSE_SERVER())
-      } else if (this[kState].listening) {
-        return Promise.reject(new FST_ERR_REOPENED_SERVER())
-      }
+  const cb = typeof args[args.length - 1] === 'function' ? args.pop() : undefined
+  const options = { cb }
 
-      return this.ready().then(() => {
-        let errEventHandler
-        const errEvent = new Promise((resolve, reject) => {
-          errEventHandler = (err) => {
-            this[kState].listening = false
-            reject(err)
-          }
-          server.once('error', errEventHandler)
-        })
-        const listen = new Promise((resolve, reject) => {
-          server.listen(listenOptions, () => {
-            server.removeListener('error', errEventHandler)
-            resolve(logServerAddress())
-          })
-          // we set it afterwards because listen can throw
-          this[kState].listening = true
-        })
+  const firstArg = args[0]
+  const argsLength = args.length
+  const lastArg = args[argsLength - 1]
+  if (typeof firstArg === 'string' && isNaN(firstArg)) {
+    /* Deal with listen (pipe[, backlog]) */
+    options.path = firstArg
+    options.backlog = argsLength > 1 ? lastArg : undefined
+  } else {
+    /* Deal with listen ([port[, host[, backlog]]]) */
+    options.port = argsLength >= 1 && Number.isInteger(firstArg) ? firstArg : 0
+    // This will listen to what localhost is.
+    // It can be 127.0.0.1 or ::1, depending on the operating system.
+    // Fixes https://github.com/fastify/fastify/issues/1022.
+    options.host = argsLength >= 2 && args[1] ? args[1] : 'localhost'
+    options.backlog = argsLength >= 3 ? args[2] : undefined
+  }
 
-        return Promise.race([
-          errEvent, // e.g invalid port range error is always emitted before the server listening
-          listen
-        ])
-      })
-    }
+  return options
+}
 
-    const logServerAddress = () => {
-      let address = server.address()
-      const isUnixSocket = typeof address === 'string'
-      /* istanbul ignore next */
-      if (!isUnixSocket) {
-        if (address.address.indexOf(':') === -1) {
-          address = address.address + ':' + address.port
-        } else {
-          address = '[' + address.address + ']:' + address.port
-        }
-      }
-      /* istanbul ignore next */
-      address = (isUnixSocket ? '' : ('http' + (this[kOptions].https ? 's' : '') + '://')) + address
-      this.log.info('Server listening at ' + address)
-      return address
+function logServerAddress (server) {
+  let address = server.address()
+  const isUnixSocket = typeof address === 'string'
+  /* istanbul ignore next */
+  if (!isUnixSocket) {
+    if (address.address.indexOf(':') === -1) {
+      address = address.address + ':' + address.port
+    } else {
+      address = '[' + address.address + ']:' + address.port
     }
-
-    if (cb === undefined) return listenPromise(listenOptions)
-
-    this.ready(err => {
-      if (err != null) return cb(err)
-
-      if (this[kState].listening && this[kState].closing) {
-        return cb(new FST_ERR_REOPENED_CLOSE_SERVER(), null)
-      } else if (this[kState].listening) {
-        return cb(new FST_ERR_REOPENED_SERVER(), null)
-      }
-
-      server.once('error', wrap)
-      server.listen(listenOptions, wrap)
-
-      this[kState].listening = true
-    })
   }
+  /* istanbul ignore next */
+  address = (isUnixSocket ? '' : ('http' + (this[kOptions].https ? 's' : '') + '://')) + address
+
+  this.log.info('Server listening at ' + address)
+  return address
 }
 
 function http2 () {
@@ -177,5 +305,3 @@ function sessionTimeout (timeout) {
 function close () {
   this.close()
 }
-
-module.exports = { createServer }

package/lib/symbols.js

@@ -3,12 +3,12 @@
 const keys = {
   kAvvioBoot: Symbol('fastify.avvioBoot'),
   kChildren: Symbol('fastify.children'),
+  kServerBindings: Symbol('fastify.serverBindings'),
   kBodyLimit: Symbol('fastify.bodyLimit'),
   kRoutePrefix: Symbol('fastify.routePrefix'),
   kLogLevel: Symbol('fastify.logLevel'),
   kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
-  kHooksDeprecatedPreParsing: Symbol('fastify.hooks.DeprecatedPreParsing'),
   kSchemaController: Symbol('fastify.schemaController'),
   kSchemaHeaders: Symbol('headers-schema'),
   kSchemaParams: Symbol('params-schema'),
@@ -30,10 +30,11 @@ const keys = {
   kReplySerializer: Symbol('fastify.reply.serializer'),
   kReplyIsError: Symbol('fastify.reply.isError'),
   kReplyHeaders: Symbol('fastify.reply.headers'),
+  kReplyTrailers: Symbol('fastify.reply.trailers'),
   kReplyHasStatusCode: Symbol('fastify.reply.hasStatusCode'),
-  kReplySent: Symbol('fastify.reply.sent'),
-  kReplySentOverwritten: Symbol('fastify.reply.sentOverwritten'),
+  kReplyHijacked: Symbol('fastify.reply.hijacked'),
   kReplyStartTime: Symbol('fastify.reply.startTime'),
+  kReplyNextErrorHandler: Symbol('fastify.reply.nextErrorHandler'),
   kReplyEndTime: Symbol('fastify.reply.endTime'),
   kReplyErrorHandlerCalled: Symbol('fastify.reply.errorHandlerCalled'),
   kReplyIsRunningOnErrorHook: Symbol('fastify.reply.isRunningOnErrorHook'),
@@ -45,6 +46,7 @@ const keys = {
   // This symbol is only meant to be used for fastify tests and should not be used for any other purpose
   kTestInternals: Symbol('fastify.testInternals'),
   kErrorHandler: Symbol('fastify.errorHandler'),
+  kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
   kKeepAliveConnections: Symbol('fastify.keepAliveConnections')
 }
 

package/lib/validation.js

@@ -27,13 +27,14 @@ function compileSchemasForSerialization (context, compile) {
 }
 
 function compileSchemasForValidation (context, compile) {
-  if (!context.schema) {
+  const { schema } = context
+  if (!schema) {
     return
   }
 
   const { method, url } = context.config || {}
 
-  const headers = context.schema.headers
+  const headers = schema.headers
   if (headers && Object.getPrototypeOf(headers) !== Object.prototype) {
     // do not mess with non-literals, e.g. Joi schemas
     context[headersSchema] = compile({ schema: headers, method, url, httpPart: 'headers' })
@@ -54,21 +55,22 @@ function compileSchemasForValidation (context, compile) {
     context[headersSchema] = compile({ schema: headersSchemaLowerCase, method, url, httpPart: 'headers' })
   }
 
-  if (context.schema.body) {
-    context[bodySchema] = compile({ schema: context.schema.body, method, url, httpPart: 'body' })
+  if (schema.body) {
+    context[bodySchema] = compile({ schema: schema.body, method, url, httpPart: 'body' })
   }
 
-  if (context.schema.querystring) {
-    context[querystringSchema] = compile({ schema: context.schema.querystring, method, url, httpPart: 'querystring' })
+  if (schema.querystring) {
+    context[querystringSchema] = compile({ schema: schema.querystring, method, url, httpPart: 'querystring' })
   }
 
-  if (context.schema.params) {
-    context[paramsSchema] = compile({ schema: context.schema.params, method, url, httpPart: 'params' })
+  if (schema.params) {
+    context[paramsSchema] = compile({ schema: schema.params, method, url, httpPart: 'params' })
   }
 }
 
 function validateParam (validatorFunction, request, paramName) {
-  const ret = validatorFunction && validatorFunction(request[paramName])
+  const isUndefined = request[paramName] === undefined
+  const ret = validatorFunction && validatorFunction(isUndefined ? null : request[paramName])
   if (ret === false) return validatorFunction.errors
   if (ret && ret.error) return ret.error
   if (ret && ret.value) request[paramName] = ret.value

package/lib/warnings.js

@@ -4,21 +4,9 @@ const warning = require('process-warning')()
 
 /**
  * Deprecation codes:
- *   - FSTDEP001
- *   - FSTDEP002
- *   - FSTDEP003
- *   - FSTDEP004
  *   - FSTDEP005
  */
 
-warning.create('FastifyDeprecation', 'FSTDEP001', 'You are accessing the Node.js core request object via "request.req", Use "request.raw" instead.')
-
-warning.create('FastifyDeprecation', 'FSTDEP002', 'You are accessing the Node.js core response object via "reply.res", Use "reply.raw" instead.')
-
-warning.create('FastifyDeprecation', 'FSTDEP003', 'You are using the legacy Content Type Parser function signature. Use the one suggested in the documentation instead.')
-
-warning.create('FastifyDeprecation', 'FSTDEP004', 'You are using the legacy preParsing hook signature. Use the one suggested in the documentation instead.')
-
 warning.create('FastifyDeprecation', 'FSTDEP005', 'You are accessing the deprecated "request.connection" property. Use "request.socket" instead.')
 
 warning.create('FastifyDeprecation', 'FSTDEP006', 'You are decorating Request/Reply with a reference type. This reference is shared amongst all requests. Use onRequest hook instead. Property: %s')
@@ -29,4 +17,8 @@ warning.create('FastifyDeprecation', 'FSTDEP008', 'You are using route constrain
 
 warning.create('FastifyDeprecation', 'FSTDEP009', 'You are using a custom route versioning strategy via the server { versioning: "..." } option, use { constraints: { version: "..." } } option instead.')
 
+warning.create('FastifyDeprecation', 'FSTDEP010', 'Modifying the "reply.sent" property is deprecated. Use the "reply.hijack()" method instead.')
+
+warning.create('FastifyDeprecation', 'FSTDEP011', 'Variadic listen method is deprecated. Please use ".listen(optionsObject)" instead. The variadic signature will be removed in `fastify@5`.')
+
 module.exports = warning

package/lib/wrapThenable.js

@@ -2,40 +2,33 @@
 
 const {
   kReplyIsError,
-  kReplySent,
-  kReplySentOverwritten
+  kReplyHijacked
 } = require('./symbols')
 
-const { FST_ERR_PROMISE_NOT_FULFILLED } = require('./errors')
-
 function wrapThenable (thenable, reply) {
   thenable.then(function (payload) {
-    if (reply[kReplySentOverwritten] === true) {
+    if (reply[kReplyHijacked] === true) {
       return
     }
 
     // this is for async functions that
     // are using reply.send directly
-    if (payload !== undefined || (reply.raw.statusCode === 204 && reply[kReplySent] === false)) {
+    if (payload !== undefined || reply.sent === false) {
       // we use a try-catch internally to avoid adding a catch to another
       // promise, increase promise perf by 10%
       try {
         reply.send(payload)
       } catch (err) {
-        reply[kReplySent] = false
         reply[kReplyIsError] = true
         reply.send(err)
       }
-    } else if (reply[kReplySent] === false) {
-      reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULFILLED() }, "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
     }
   }, function (err) {
-    if (reply[kReplySentOverwritten] === true || reply.sent === true) {
+    if (reply.sent === true) {
       reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
       return
     }
 
-    reply[kReplySent] = false
     reply[kReplyIsError] = true
     reply.send(err)
   })