fastify 4.16.3 → 4.18.0

package/GOVERNANCE.md

@@ -14,8 +14,8 @@
 
 ## Lead Maintainers
 
-Fastify Lead Maintainers are the founder of the project and the organization
-owners. They are the only members of the `@fastify/leads` team. The Lead
+Fastify Lead Maintainers are the organization owners.
+They are the only members of the `@fastify/leads` team. The Lead
 Maintainers are the curator of the Fastify project and their key responsibility
 is to issue releases of Fastify and its dependencies.
 

package/README.md

@@ -38,6 +38,18 @@ resources of your server, knowing that you are serving the highest number of
 requests as possible, without sacrificing security validations and handy
 development?
 
+Enter Fastify. Fastify is a web framework highly focused on providing the best
+developer experience with the least overhead and a powerful plugin architecture.
+It is inspired by Hapi and Express and as far as we know, it is one of the
+fastest web frameworks in town.
+
+The `main` branch refers to the Fastify `v4` release. Check out the
+[`v3.x` branch](https://github.com/fastify/fastify/tree/3.x) for `v3`.
+
+
+
+### Table of Contents 
+
  - [Quick start](#quick-start)
  - [Install](#install)
  - [Example](#example)
@@ -51,13 +63,6 @@ development?
  - [Hosted by](#hosted-by)
  - [License](#license)
 
-Enter Fastify. Fastify is a web framework highly focused on providing the best
-developer experience with the least overhead and a powerful plugin architecture.
-It is inspired by Hapi and Express and as far as we know, it is one of the
-fastest web frameworks in town.
-
-This branch refers to the Fastify v4 release. Check out the
-[v3.x](https://github.com/fastify/fastify/tree/v3.x) branch for v3.
 
 ### Quick start
 
@@ -189,7 +194,7 @@ changes should be based on **`branch 1.x`**. In a similar way, all Fastify
 - **Highly performant:** as far as we know, Fastify is one of the fastest web
   frameworks in town, depending on the code complexity we can serve up to 76+
   thousand requests per second.
-- **Extendible:** Fastify is fully extensible via its hooks, plugins and
+- **Extensible:** Fastify is fully extensible via its hooks, plugins and
   decorators.
 - **Schema based:** even if it is not mandatory we recommend to use [JSON
   Schema](https://json-schema.org/) to validate your routes and serialize your
@@ -339,8 +344,6 @@ listed in alphabetical order.
 * [__Frazer Smith__](https://github.com/Fdawgs), <https://www.npmjs.com/~fdawgs>
 * [__Manuel Spigolon__](https://github.com/eomm),
   <https://twitter.com/manueomm>, <https://www.npmjs.com/~eomm>
-* [__Rafael Gonzaga__](https://github.com/rafaelgss),
-  <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
 * [__Simone Busoli__](https://github.com/simoneb),
   <https://twitter.com/simonebu>, <https://www.npmjs.com/~simoneb>
 

package/docs/Guides/Ecosystem.md

@@ -310,6 +310,9 @@ section.
 - [`fastify-esso`](https://github.com/patrickpissurno/fastify-esso) The easiest
   authentication plugin for Fastify, with built-in support for Single sign-on
   (and great documentation).
+- [`fastify-evervault`](https://github.com/Briscoooe/fastify-evervault/) Fastify
+  plugin for instantiating and encapsulating the 
+  [Evervault](https://evervault.com/) client.
 - [`fastify-explorer`](https://github.com/Eomm/fastify-explorer) Get control of
   your decorators across all the encapsulated contexts.
 - [`fastify-favicon`](https://github.com/smartiniOnGitHub/fastify-favicon)
@@ -465,6 +468,9 @@ middlewares into Fastify plugins
   ORM.
 - [`fastify-objectionjs-classes`](https://github.com/kamikazechaser/fastify-objectionjs-classes)
   Plugin to cherry-pick classes from objectionjs ORM.
+- [`fastify-opaque-apake`](https://github.com/squirrelchat/fastify-opaque-apake)
+  A Fastify plugin to implement the OPAQUE aPAKE protocol. Uses
+  [@squirrelchat/opaque-wasm-server](https://github.com/squirrelchat/opaque-wasm).
 - [`fastify-openapi-docs`](https://github.com/ShogunPanda/fastify-openapi-docs)
   A Fastify plugin that generates OpenAPI spec automatically.
 - [`fastify-openapi-glue`](https://github.com/seriousme/fastify-openapi-glue)

package/docs/Guides/Serverless.md

@@ -489,10 +489,21 @@ const app = Fastify({
 });
 
 // Register your application as a normal plugin.
-app.register(import("../src/app"));
+app.register(import("../src/app.js"));
 
 export default async (req, res) => {
     await app.ready();
     app.server.emit('request', req, res);
 }
 ```
+
+In `src/app.js` define the plugin.
+```js
+async function routes (fastify, options) {
+  fastify.get('/', async (request, reply) => {
+    return { hello: 'world' }
+  })
+}
+
+export default routes;
+```

package/docs/Reference/Errors.md

@@ -429,6 +429,11 @@ Handler for the route must be a function.
 
 Missing handler function for the route.
 
+#### FST_ERR_ROUTE_METHOD_INVALID
+<a id="FST_ERR_ROUTE_METHOD_INVALID"></a>
+
+Method is not a valid value.
+
 #### FST_ERR_ROUTE_METHOD_NOT_SUPPORTED
 <a id="FST_ERR_ROUTE_METHOD_NOT_SUPPORTED"></a>
 

package/docs/Reference/LTS.md

@@ -48,7 +48,7 @@ A "month" is defined as 30 consecutive days.
 | 1.0.0   | 2018-03-06   | 2019-09-01      | 6, 8, 9, 10, 11      |
 | 2.0.0   | 2019-02-25   | 2021-01-31      | 6, 8, 10, 12, 14     |
 | 3.0.0   | 2020-07-07   | 2023-06-30      | 10, 12, 14, 16, 18   |
-| 4.0.0   | 2022-06-08   | TBD             | 14, 16, 18           |
+| 4.0.0   | 2022-06-08   | TBD             | 14, 16, 18, 20       |
 
 ### CI tested operating systems
 <a id="supported-os"></a>
@@ -61,10 +61,10 @@ YAML workflow labels below:
 
 | OS      | YAML Workflow Label    | Package Manager           | Node.js      |
 |---------|------------------------|---------------------------|--------------|
-| Linux   | `ubuntu-latest`        | npm                       | 14,16,18     |
-| Linux   | `ubuntu-latest`        | yarn,pnpm                 | 14,16,18     |
-| Windows | `windows-latest`       | npm                       | 14,16,18     |
-| MacOS   | `macos-latest`         | npm                       | 14,16,18     |
+| Linux   | `ubuntu-latest`        | npm                       | 14,16,18,20  |
+| Linux   | `ubuntu-latest`        | yarn,pnpm                 | 14,16,18,20  |
+| Windows | `windows-latest`       | npm                       | 14,16,18,20  |
+| MacOS   | `macos-latest`         | npm                       | 14,16,18,20  |
 
 Using [yarn](https://yarnpkg.com/) might require passing the `--ignore-engines`
 flag.

package/docs/Reference/Lifecycle.md

@@ -1,6 +1,8 @@
 <h1 align="center">Fastify</h1>
 
 ## Lifecycle
+<a id="lifecycle"></a>
+
 Following the schema of the internal lifecycle of Fastify.
 
 On the right branch of every section there is the next phase of the lifecycle,
@@ -49,6 +51,7 @@ NB (*): If `reply.raw` is used to send a response back to the user, `onResponse`
 hooks will still be executed
 
 ## Reply Lifecycle
+<a id="reply-lifecycle"></a>
 
 Whenever the user handles the request, the result may be:
 

package/docs/Reference/Logging.md

@@ -22,7 +22,7 @@ const fastify = require('fastify')({
 ```
 
 Enabling the logger with appropriate configuration for both local development
-and production and test environment requires bit more configuration:
+and production and test environment requires a bit more configuration:
 
 ```js
 const envToLogger = {
@@ -108,6 +108,7 @@ serialize objects with `req`, `res`, and `err` properties. The object received
 by `req` is the Fastify [`Request`](./Request.md) object, while the object
 received by `res` is the Fastify [`Reply`](./Reply.md) object. This behaviour
 can be customized by specifying custom serializers.
+
 ```js
 const fastify = require('fastify')({
   logger: {
@@ -152,6 +153,34 @@ const fastify = require('fastify')({
   }
 });
 ```
+
+**Note**: In certain cases, the [`Reply`](./Reply.md) object passed to the `res`
+serializer cannot be fully constructed. When writing a custom `res` serializer,
+it is necessary to check for the existence of any properties on `reply` aside
+from `statusCode`, which is always present. For example, the existence of
+`getHeaders` must be verified before it can be called:
+
+```js
+const fastify = require('fastify')({
+  logger: {
+    transport: {
+      target: 'pino-pretty'
+    },
+    serializers: {
+      res (reply) {
+        // The default
+        return {
+          statusCode: reply.statusCode
+          headers: typeof reply.getHeaders === 'function'
+            ? reply.getHeaders()
+            : {}
+        }
+      },
+    }
+  }
+});
+```
+
 **Note**: The body cannot be serialized inside a `req` method because the
 request is serialized when we create the child logger. At that time, the body is
 not yet parsed.
@@ -167,6 +196,10 @@ app.addHook('preHandler', function (req, reply, done) {
 })
 ```
 
+**Note**: Care should be take to ensure serializers never throw, as an error
+thrown from a serializer has the potential to cause the Node process to exit.
+See the [Pino documentation](https://getpino.io/#/docs/api?id=opt-serializers)
+on serializers for more information.
 
 *Any logger other than Pino will ignore this option.*
 

package/docs/Reference/Reply.md

@@ -708,6 +708,20 @@ fastify.get('/streams', async function (request, reply) {
   return reply
 })
 ```
+
+#### TypedArrays
+<a id="send-typedarrays"></a>
+
+`send` manages TypedArray and sets the `'Content-Type'=application/octet-stream'`
+header if not already set.
+```js
+const fs = require('fs')
+fastify.get('/streams', function (request, reply) {
+  const typedArray = new Uint16Array(10)
+  reply.send(typedArray)
+})
+```
+
 #### Errors
 <a id="errors"></a>
 
@@ -789,6 +803,11 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
+Beware that calling `reply.send(error)` in your custom error handler will send
+the error to the default error handler.
+Check out the [Reply Lifecycle](./Lifecycle.md#reply-lifecycle)
+for more information.
+
 The not found errors generated by the router will use the
 [`setNotFoundHandler`](./Server.md#setnotfoundhandler)
 

package/docs/Reference/Request.md

@@ -145,7 +145,7 @@ console.log(validate({ foo: 0.5 })) // false
 console.log(validate.errors) // validation errors
 ```
 
-See [.compilaValidationSchema(schema, [httpStatus])](#compilevalidationschema)
+See [.compileValidationSchema(schema, [httpStatus])](#compilevalidationschema)
 for more information on how to compile validation function.
 
 ### .compileValidationSchema(schema, [httpPart])

package/docs/Reference/Server.md

@@ -63,6 +63,7 @@ describes the properties available in that options object.
     - [prefix](#prefix)
     - [pluginName](#pluginname)
     - [hasPlugin](#hasplugin)
+    - [listeningOrigin](#listeningOrigin)
     - [log](#log)
     - [version](#version)
     - [inject](#inject)
@@ -828,8 +829,16 @@ URLs.
 > Rewriting a URL will modify the `url` property of the `req` object
 
 ```js
-function rewriteUrl (req) { // req is the Node.js HTTP request
-  return req.url === '/hi' ? '/hello' : req.url;
+// @param {object} req The raw Node.js HTTP request, not the `FastifyRequest` object.
+// @this Fastify The root Fastify instance (not an encapsulated instance).
+// @returns {string} The path that the request should be mapped to.
+function rewriteUrl (req) { 
+  if (req.url === '/hi') {
+    this.log.debug({ originalUrl: req.url, url: '/hello' }, 'rewrite url');
+    return '/hello'
+  } else {
+    return req.url;
+  }
 }
 ```
 
@@ -1231,6 +1240,15 @@ fastify.ready(() => {
 })
 ```
 
+### listeningOrigin
+<a id="listeningOrigin"></a>
+
+The current origin the server is listening to.
+For example, a TCP socket based server returns
+a base address like `http://127.0.0.1:3000`,
+and a Unix socket server will return the socket
+path, e.g. `fastify.temp.sock`.
+
 #### log
 <a id="log"></a>
 

package/docs/Reference/Validation-and-Serialization.md

@@ -19,8 +19,9 @@ All the examples in this section are using the [JSON Schema Draft
 > use with user-provided schemas. See [Ajv](https://npm.im/ajv) and
 > [fast-json-stringify](https://npm.im/fast-json-stringify) for more details.
 >
-> Moreover, the [`$async` Ajv
-> feature](https://ajv.js.org/guide/async-validation.html) should not be used as
+> Regardless the [`$async` Ajv
+> feature](https://ajv.js.org/guide/async-validation.html) is supported
+> by Fastify, it should not be used as
 > part of the first validation strategy. This option is used to access Databases
 > and reading them during the validation process may lead to Denial of Service
 > Attacks to your application. If you need to run `async` tasks, use [Fastify's

package/examples/benchmark/body.json

@@ -0,0 +1,3 @@
+{
+  "hello": "world"
+}

package/fastify.d.ts

@@ -148,7 +148,12 @@ declare namespace fastify {
       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,
+    rewriteUrl?: (
+      // The RawRequestDefaultExpression, RawReplyDefaultExpression, and FastifyTypeProviderDefault parameters
+      // should be narrowed further but those generic parameters are not passed to this FastifyServerOptions type 
+      this: FastifyInstance<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, Logger, FastifyTypeProviderDefault>,
+      req: RawRequestDefaultExpression<RawServer>
+    ) => string,
     schemaErrorFormatter?: SchemaErrorFormatter,
     /**
      * listener to error events emitted by client connections

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.16.3'
+const VERSION = '4.18.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -348,6 +348,16 @@ function fastify (options) {
   }
 
   Object.defineProperties(fastify, {
+    listeningOrigin: {
+      get () {
+        const address = this.addresses().slice(-1).pop()
+        /* istanbul ignore if windows: unix socket is not testable on Windows platform */
+        if (typeof address === 'string') {
+          return address
+        }
+        return `${this[kOptions].https ? 'https' : 'http'}://${address.address}:${address.port}`
+      }
+    },
     pluginName: {
       configurable: true,
       get () {
@@ -606,7 +616,6 @@ function fastify (options) {
     } 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) => {
@@ -689,7 +698,7 @@ function fastify (options) {
       const reply = new Reply(res, request, childLogger)
       return frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
     }
-    const body = `{"error":"Bad Request","message":"'${path}' is not a valid url component","statusCode":400}`
+    const body = `{"error":"Bad Request","code":"FST_ERR_BAD_URL","message":"'${path}' is not a valid url component","statusCode":400}`
     res.writeHead(400, {
       'Content-Type': 'application/json',
       'Content-Length': body.length
@@ -784,16 +793,12 @@ function fastify (options) {
       // only call isAsyncConstraint once
       if (isAsync === undefined) isAsync = router.isAsyncConstraint()
       if (rewriteUrl) {
-        const originalUrl = req.url
-        const url = rewriteUrl(req)
-        if (originalUrl !== url) {
-          logger.debug({ originalUrl, url }, 'rewrite url')
-          if (typeof url === 'string') {
-            req.url = url
-          } else {
-            const err = new FST_ERR_ROUTE_REWRITE_NOT_STR(req.url, typeof url)
-            req.destroy(err)
-          }
+        const url = rewriteUrl.call(fastify, req)
+        if (typeof url === 'string') {
+          req.url = url
+        } else {
+          const err = new FST_ERR_ROUTE_REWRITE_NOT_STR(req.url, typeof url)
+          req.destroy(err)
         }
       }
       router.routing(req, res, buildAsyncConstraintCallback(isAsync, req, res))

package/lib/contentTypeParser.js

@@ -248,7 +248,9 @@ function rawBody (request, reply, options, parser, done) {
     payload.removeListener('error', onEnd)
 
     if (err !== undefined) {
-      err.statusCode = 400
+      if (!(typeof err.statusCode === 'number' && err.statusCode >= 400)) {
+        err.statusCode = 400
+      }
       reply[kReplyIsError] = true
       reply.code(err.statusCode).send(err)
       return

package/lib/errors.js

@@ -336,6 +336,11 @@ const codes = {
     'Missing handler function for "%s:%s" route.',
     500
   ),
+  FST_ERR_ROUTE_METHOD_INVALID: createError(
+    'FST_ERR_ROUTE_METHOD_INVALID',
+    'Provided method is invalid!',
+    500
+  ),
   FST_ERR_ROUTE_METHOD_NOT_SUPPORTED: createError(
     'FST_ERR_ROUTE_METHOD_NOT_SUPPORTED',
     '%s method is not supported.',

package/lib/handleRequest.js

@@ -89,14 +89,25 @@ function preValidationCallback (err, request, reply) {
     return
   }
 
-  const result = validateSchema(reply[kRouteContext], request)
-  if (result) {
+  const validationErr = validateSchema(reply[kRouteContext], request)
+  const isAsync = (validationErr && typeof validationErr.then === 'function') || false
+
+  if (isAsync) {
+    const cb = validationCompleted.bind(null, request, reply)
+    validationErr.then(cb, cb)
+  } else {
+    validationCompleted(request, reply, validationErr)
+  }
+}
+
+function validationCompleted (request, reply, validationErr) {
+  if (validationErr) {
     if (reply[kRouteContext].attachValidation === false) {
-      reply.send(result)
+      reply.send(validationErr)
       return
     }
 
-    reply.request.validationError = result
+    reply.request.validationError = validationErr
   }
 
   // preHandler hook

package/lib/reply.js

@@ -148,11 +148,12 @@ Reply.prototype.send = function (payload) {
       return this
     }
 
-    if (Buffer.isBuffer(payload)) {
+    if (payload?.buffer instanceof ArrayBuffer) {
       if (hasContentType === false) {
         this[kReplyHeaders]['content-type'] = CONTENT_TYPE.OCTET
       }
-      onSendHook(this, payload)
+      const payloadToSend = Buffer.isBuffer(payload) ? payload : Buffer.from(payload.buffer)
+      onSendHook(this, payloadToSend)
       return this
     }
 

package/lib/route.js

@@ -27,6 +27,7 @@ const {
   FST_ERR_ROUTE_HANDLER_NOT_FN,
   FST_ERR_ROUTE_MISSING_HANDLER,
   FST_ERR_ROUTE_METHOD_NOT_SUPPORTED,
+  FST_ERR_ROUTE_METHOD_INVALID,
   FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED,
   FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT
 } = require('./errors')
@@ -185,10 +186,12 @@ function buildRouting (options) {
     if (Array.isArray(opts.method)) {
       // eslint-disable-next-line no-var
       for (var i = 0; i < opts.method.length; ++i) {
-        validateMethodAndSchemaBodyOption(opts.method[i], path, opts.schema)
+        opts.method[i] = normalizeAndValidateMethod(opts.method[i])
+        validateSchemaBodyOption(opts.method[i], path, opts.schema)
       }
     } else {
-      validateMethodAndSchemaBodyOption(opts.method, path, opts.schema)
+      opts.method = normalizeAndValidateMethod(opts.method)
+      validateSchemaBodyOption(opts.method, path, opts.schema)
     }
 
     if (!opts.handler) {
@@ -526,11 +529,19 @@ function handleTimeout () {
   )
 }
 
-function validateMethodAndSchemaBodyOption (method, path, schema) {
+function normalizeAndValidateMethod (method) {
+  if (typeof method !== 'string') {
+    throw new FST_ERR_ROUTE_METHOD_INVALID()
+  }
+  method = method.toUpperCase()
   if (supportedMethods.indexOf(method) === -1) {
     throw new FST_ERR_ROUTE_METHOD_NOT_SUPPORTED(method)
   }
 
+  return method
+}
+
+function validateSchemaBodyOption (method, path, schema) {
   if ((method === 'GET' || method === 'HEAD') && schema && schema.body) {
     throw new FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED(method, path)
   }

package/lib/schemas.js

@@ -44,6 +44,16 @@ Schemas.prototype.getSchema = function (schemaId) {
   return this.store[schemaId]
 }
 
+/**
+ * Checks whether a schema is a non-plain object.
+ *
+ * @param {*} schema the schema to check
+ * @returns {boolean} true if schema has a custom prototype
+ */
+function isCustomSchemaPrototype (schema) {
+  return typeof schema === 'object' && Object.getPrototypeOf(schema) !== Object.prototype
+}
+
 function normalizeSchema (routeSchemas, serverOptions) {
   if (routeSchemas[kSchemaVisited]) {
     return routeSchemas
@@ -60,33 +70,20 @@ function normalizeSchema (routeSchemas, serverOptions) {
 
   generateFluentSchema(routeSchemas)
 
-  // let's check if our schemas have a custom prototype
-  for (const key of ['headers', 'querystring', 'params', 'body']) {
-    if (typeof routeSchemas[key] === 'object' && Object.getPrototypeOf(routeSchemas[key]) !== Object.prototype) {
-      routeSchemas[kSchemaVisited] = true
-      return routeSchemas
+  for (const key of SCHEMAS_SOURCE) {
+    const schema = routeSchemas[key]
+    if (schema && !isCustomSchemaPrototype(schema)) {
+      routeSchemas[key] = getSchemaAnyway(schema, serverOptions.jsonShorthand)
     }
   }
 
-  if (routeSchemas.body) {
-    routeSchemas.body = getSchemaAnyway(routeSchemas.body, serverOptions.jsonShorthand)
-  }
-
-  if (routeSchemas.headers) {
-    routeSchemas.headers = getSchemaAnyway(routeSchemas.headers, serverOptions.jsonShorthand)
-  }
-
-  if (routeSchemas.querystring) {
-    routeSchemas.querystring = getSchemaAnyway(routeSchemas.querystring, serverOptions.jsonShorthand)
-  }
-
-  if (routeSchemas.params) {
-    routeSchemas.params = getSchemaAnyway(routeSchemas.params, serverOptions.jsonShorthand)
-  }
-
   if (routeSchemas.response) {
     const httpCodes = Object.keys(routeSchemas.response)
     for (const code of httpCodes) {
+      if (isCustomSchemaPrototype(routeSchemas.response[code])) {
+        continue
+      }
+
       const contentProperty = routeSchemas.response[code].content
 
       let hasContentMultipleContentTypes = false

package/lib/server.js

@@ -127,6 +127,7 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
           cb: (_ignoreErr) => {
             binded++
 
+            /* istanbul ignore next: the else won't be taken unless listening fails */
             if (!_ignoreErr) {
               this[kServerBindings].push(secondaryServer)
             }
@@ -144,6 +145,7 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
         mainServer.on('unref', closeSecondary)
         mainServer.on('close', closeSecondary)
         mainServer.on('error', closeSecondary)
+        this[kState].listening = false
         listenCallback.call(this, secondaryServer, secondaryOpts)()
       }
     }
@@ -278,19 +280,22 @@ function compileValidateHTTPVersion (options) {
 
 function getServerInstance (options, httpHandler) {
   let server = null
+  // node@20 do not accepts options as boolean
+  // we need to provide proper https option
+  const httpsOptions = options.https === true ? {} : options.https
   if (options.serverFactory) {
     server = options.serverFactory(httpHandler, options)
   } else if (options.http2) {
-    if (options.https) {
-      server = http2().createSecureServer(options.https, httpHandler)
+    if (typeof httpsOptions === 'object') {
+      server = http2().createSecureServer(httpsOptions, httpHandler)
     } else {
       server = http2().createServer(httpHandler)
     }
     server.on('session', sessionTimeout(options.http2SessionTimeout))
   } else {
     // this is http1
-    if (options.https) {
-      server = https.createServer(options.https, httpHandler)
+    if (httpsOptions) {
+      server = https.createServer(httpsOptions, httpHandler)
     } else {
       server = http.createServer(options.http, httpHandler)
     }