fastify 3.17.0 → 3.19.1

package/lib/request.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const proxyAddr = require('@fastify/proxy-addr')
+const proxyAddr = require('proxy-addr')
 const semver = require('semver')
 const warning = require('./warnings')
 

package/lib/route.js

@@ -227,7 +227,7 @@ function buildRouting (options) {
       }
       const constraints = opts.constraints || {}
       if (opts.version) {
-        warning.emit('FSTDEP006')
+        warning.emit('FSTDEP008')
         constraints.version = opts.version
       }
 
@@ -296,7 +296,7 @@ function buildRouting (options) {
         fourOhFour.setContext(this, context)
 
         if (opts.schema) {
-          context.schema = normalizeSchema(context.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)) {

package/lib/schemas.js

@@ -43,7 +43,7 @@ Schemas.prototype.getSchema = function (schemaId) {
   return this.store[schemaId]
 }
 
-function normalizeSchema (routeSchemas) {
+function normalizeSchema (routeSchemas, serverOptions) {
   if (routeSchemas[kSchemaVisited]) {
     return routeSchemas
   }
@@ -67,25 +67,25 @@ function normalizeSchema (routeSchemas) {
   }
 
   if (routeSchemas.body) {
-    routeSchemas.body = getSchemaAnyway(routeSchemas.body)
+    routeSchemas.body = getSchemaAnyway(routeSchemas.body, serverOptions.jsonShorthand)
   }
 
   if (routeSchemas.headers) {
-    routeSchemas.headers = getSchemaAnyway(routeSchemas.headers)
+    routeSchemas.headers = getSchemaAnyway(routeSchemas.headers, serverOptions.jsonShorthand)
   }
 
   if (routeSchemas.querystring) {
-    routeSchemas.querystring = getSchemaAnyway(routeSchemas.querystring)
+    routeSchemas.querystring = getSchemaAnyway(routeSchemas.querystring, serverOptions.jsonShorthand)
   }
 
   if (routeSchemas.params) {
-    routeSchemas.params = getSchemaAnyway(routeSchemas.params)
+    routeSchemas.params = getSchemaAnyway(routeSchemas.params, serverOptions.jsonShorthand)
   }
 
   if (routeSchemas.response) {
     const httpCodes = Object.keys(routeSchemas.response)
     for (const code of httpCodes) {
-      routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code])
+      routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code], serverOptions.jsonShorthand)
     }
   }
 
@@ -110,8 +110,8 @@ function generateFluentSchema (schema) {
   }
 }
 
-function getSchemaAnyway (schema) {
-  if (schema.$ref || schema.oneOf || schema.allOf || schema.anyOf || schema.$merge || schema.$patch) return 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',

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "fastify",
-  "version": "3.17.0",
+  "version": "3.19.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
   "types": "fastify.d.ts",
   "scripts": {
     "bench": "branchcmp -r 2 -g -s \"npm run benchmark\"",
-    "benchmark": "npx concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"npx autocannon -c 100 -d 5 -p 10 localhost:3000/\"",
+    "benchmark": "npx concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"npx autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
     "coverage": "npm run unit -- --cov --coverage-report=html",
     "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\"",
     "lint": "npm run lint:standard && npm run lint:typescript",
@@ -114,25 +114,22 @@
     "url": "https://github.com/fastify/fastify/issues"
   },
   "homepage": "https://www.fastify.io/",
-  "engines": {
-    "node": ">=10.16.0"
-  },
   "devDependencies": {
     "@fastify/ajv-compiler-8": "github:fastify/ajv-compiler#ajv-8",
+    "@fastify/pre-commit": "^2.0.1",
     "@hapi/joi": "^17.1.1",
     "@sinonjs/fake-timers": "^7.0.0",
-    "@types/node": "^15.3.0",
+    "@types/node": "^16.0.0",
     "@types/pino": "^6.0.1",
     "@typescript-eslint/eslint-plugin": "^4.5.0",
     "@typescript-eslint/parser": "^4.5.0",
+    "JSONStream": "^1.3.5",
     "ajv": "^6.0.0",
     "ajv-errors": "^1.0.1",
     "ajv-i18n": "^3.5.0",
     "ajv-merge-patch": "^4.1.0",
     "ajv-pack": "^0.3.1",
-    "autocannon": "^7.0.0",
     "branch-comparer": "^1.0.2",
-    "concurrently": "^6.0.0",
     "cors": "^2.8.5",
     "coveralls": "^3.1.0",
     "dns-prefetch-control": "^0.3.0",
@@ -154,10 +151,8 @@
     "hsts": "^2.2.0",
     "http-errors": "^1.7.1",
     "ienoopen": "^1.1.0",
-    "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
     "pem": "^1.14.4",
-    "pre-commit": "^1.2.2",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "send": "^0.17.1",
@@ -177,7 +172,6 @@
   },
   "dependencies": {
     "@fastify/ajv-compiler": "^1.0.0",
-    "@fastify/proxy-addr": "^3.0.0",
     "abstract-logging": "^2.0.0",
     "avvio": "^7.1.2",
     "fast-json-stringify": "^2.5.2",
@@ -187,6 +181,7 @@
     "flatstr": "^1.0.12",
     "light-my-request": "^4.2.0",
     "pino": "^6.2.1",
+    "proxy-addr": "^2.0.7",
     "readable-stream": "^3.4.0",
     "rfdc": "^1.1.4",
     "secure-json-parse": "^2.0.0",

package/test/close.test.js

@@ -4,6 +4,7 @@ const net = require('net')
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
+const { Client } = require('undici')
 
 test('close callback', t => {
   t.plan(4)
@@ -238,27 +239,23 @@ t.test('Current opened connection should continue to work after closing and retu
 })
 
 t.test('Current opened connection should not accept new incoming connections', t => {
+  t.plan(3)
   const fastify = Fastify()
-
   fastify.get('/', (req, reply) => {
     fastify.close()
-    reply.send({ hello: 'world' })
+    setTimeout(() => {
+      reply.send({ hello: 'world' })
+    }, 250)
   })
 
   fastify.listen(0, err => {
     t.error(err)
-
-    const port = fastify.server.address().port
-    const client = net.createConnection({ port: port }, () => {
-      client.write('GET / HTTP/1.1\r\n\r\n')
-
-      const newConnection = net.createConnection({ port: port })
-      newConnection.on('error', err => {
-        t.ok(err)
-        t.ok(['ECONNREFUSED', 'ECONNRESET'].includes(err.code))
-
-        client.end(() => { t.end() })
-      })
+    const instance = new Client('http://localhost:' + fastify.server.address().port)
+    instance.request({ path: '/', method: 'GET' }).then(data => {
+      t.equal(data.statusCode, 200)
+    })
+    instance.request({ path: '/', method: 'GET' }).then(data => {
+      t.equal(data.statusCode, 503)
     })
   })
 })

package/test/internals/initialConfig.test.js

@@ -27,6 +27,7 @@ test('without options passed to Fastify, initialConfig should expose default val
     bodyLimit: 1024 * 1024,
     caseSensitive: true,
     disableRequestLogging: false,
+    jsonShorthand: true,
     ignoreTrailingSlash: false,
     maxParamLength: 100,
     onProtoPoisoning: 'error',
@@ -242,6 +243,7 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       bodyLimit: 1024 * 1024,
       caseSensitive: true,
       disableRequestLogging: false,
+      jsonShorthand: true,
       ignoreTrailingSlash: true,
       maxParamLength: 100,
       onProtoPoisoning: 'error',

package/test/internals/validation.test.js

@@ -81,6 +81,9 @@ test('build schema - payload schema', t => {
 
 test('build schema - avoid repeated normalize schema', t => {
   t.plan(3)
+  const serverConfig = {
+    jsonShorthand: true
+  }
   const opts = {
     schema: {
       query: {
@@ -91,14 +94,17 @@ test('build schema - avoid repeated normalize schema', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema)
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
   t.not(kSchemaVisited, undefined)
   t.equal(opts.schema[kSchemaVisited], true)
-  t.equal(opts.schema, normalizeSchema(opts.schema))
+  t.equal(opts.schema, normalizeSchema(opts.schema, serverConfig))
 })
 
 test('build schema - query schema', t => {
   t.plan(2)
+  const serverConfig = {
+    jsonShorthand: true
+  }
   const opts = {
     schema: {
       query: {
@@ -109,7 +115,7 @@ test('build schema - query schema', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema)
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
   t.type(opts[symbols.querystringSchema].schema.type, 'string')
   t.equal(typeof opts[symbols.querystringSchema], 'function')
@@ -117,6 +123,9 @@ test('build schema - query schema', t => {
 
 test('build schema - query schema abbreviated', t => {
   t.plan(2)
+  const serverConfig = {
+    jsonShorthand: true
+  }
   const opts = {
     schema: {
       query: {
@@ -124,7 +133,7 @@ test('build schema - query schema abbreviated', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema)
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
   t.type(opts[symbols.querystringSchema].schema.type, 'string')
   t.equal(typeof opts[symbols.querystringSchema], 'function')
@@ -149,6 +158,9 @@ test('build schema - querystring schema', t => {
 
 test('build schema - querystring schema abbreviated', t => {
   t.plan(2)
+  const serverConfig = {
+    jsonShorthand: true
+  }
   const opts = {
     schema: {
       querystring: {
@@ -156,7 +168,7 @@ test('build schema - querystring schema abbreviated', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema)
+  opts.schema = normalizeSchema(opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
   t.type(opts[symbols.querystringSchema].schema.type, 'string')
   t.equal(typeof opts[symbols.querystringSchema], 'function')
@@ -165,6 +177,9 @@ test('build schema - querystring schema abbreviated', t => {
 test('build schema - must throw if querystring and query schema exist', t => {
   t.plan(2)
   try {
+    const serverConfig = {
+      jsonShorthand: true
+    }
     const opts = {
       schema: {
         query: {
@@ -181,7 +196,7 @@ test('build schema - must throw if querystring and query schema exist', t => {
         }
       }
     }
-    opts.schema = normalizeSchema(opts.schema)
+    opts.schema = normalizeSchema(opts.schema, serverConfig)
   } catch (err) {
     t.equal(err.code, 'FST_ERR_SCH_DUPLICATE')
     t.equal(err.message, 'Schema with \'querystring\' already present!')

package/test/pretty-print.test.js

@@ -121,3 +121,92 @@ test('pretty print - nested plugins', t => {
     t.match(tree, 'baz')
   })
 })
+
+test('pretty print - commonPrefix', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.get('/hello', () => {})
+  fastify.put('/hello', () => {})
+  fastify.get('/helicopter', () => {})
+
+  fastify.ready(() => {
+    const radixTree = fastify.printRoutes()
+    const flatTree = fastify.printRoutes({ commonPrefix: false })
+
+    const radixExpected = `└── /
+    ├── hel
+    │   ├── lo (GET)
+    │   └── icopter (GET)
+    └── hello (PUT)
+`
+    const flatExpected = `└── / (-)
+    ├── helicopter (GET)
+    └── hello (GET, PUT)
+`
+    t.equal(typeof radixTree, 'string')
+    t.equal(typeof flatTree, 'string')
+    t.equal(radixTree, radixExpected)
+    t.equal(flatTree, flatExpected)
+  })
+})
+
+test('pretty print - includeMeta, includeHooks', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const onTimeout = () => {}
+  fastify.get('/hello', () => {})
+  fastify.put('/hello', () => {})
+  fastify.get('/helicopter', () => {})
+
+  fastify.addHook('onRequest', () => {})
+  fastify.addHook('onTimeout', onTimeout)
+
+  fastify.ready(() => {
+    const radixTree = fastify.printRoutes({ includeHooks: true, includeMeta: ['errorHandler'] })
+    const flatTree = fastify.printRoutes({ commonPrefix: false, includeHooks: true, includeMeta: ['errorHandler'] })
+    const hooksOnly = fastify.printRoutes({ commonPrefix: false, includeHooks: true })
+
+    const radixExpected = `└── /
+    ├── hel
+    │   ├── lo (GET)
+    │   │   • (onTimeout) ["onTimeout()"]
+    │   │   • (onRequest) ["anonymous()"]
+    │   │   • (errorHandler) "defaultErrorHandler()"
+    │   └── icopter (GET)
+    │       • (onTimeout) ["onTimeout()"]
+    │       • (onRequest) ["anonymous()"]
+    │       • (errorHandler) "defaultErrorHandler()"
+    └── hello (PUT)
+        • (onTimeout) ["onTimeout()"]
+        • (onRequest) ["anonymous()"]
+        • (errorHandler) "defaultErrorHandler()"
+`
+    const flatExpected = `└── / (-)
+    ├── helicopter (GET)
+    │   • (onTimeout) ["onTimeout()"]
+    │   • (onRequest) ["anonymous()"]
+    │   • (errorHandler) "defaultErrorHandler()"
+    └── hello (GET, PUT)
+        • (onTimeout) ["onTimeout()"]
+        • (onRequest) ["anonymous()"]
+        • (errorHandler) "defaultErrorHandler()"
+`
+
+    const hooksOnlyExpected = `└── / (-)
+    ├── helicopter (GET)
+    │   • (onTimeout) ["onTimeout()"]
+    │   • (onRequest) ["anonymous()"]
+    └── hello (GET, PUT)
+        • (onTimeout) ["onTimeout()"]
+        • (onRequest) ["anonymous()"]
+`
+    t.equal(typeof radixTree, 'string')
+    t.equal(typeof flatTree, 'string')
+    t.equal(typeof hooksOnlyExpected, 'string')
+    t.equal(radixTree, radixExpected)
+    t.equal(flatTree, flatExpected)
+    t.equal(hooksOnly, hooksOnlyExpected)
+  })
+})

package/test/reply-error.test.js

@@ -472,3 +472,56 @@ invalidErrorCodes.forEach((invalidCode) => {
     })
   })
 })
+
+test('status code should be set to 500 and return an error json payload if route handler throws any non Error object expression', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/', () => {
+    /* eslint-disable-next-line */
+    throw { foo: 'bar' }
+  })
+
+  // ----
+  const reply = await fastify.inject({ method: 'GET', url: '/' })
+  t.equal(reply.statusCode, 500)
+  t.equal(JSON.parse(reply.body).foo, 'bar')
+})
+
+test('should preserve the status code set by the user if an expression is thrown in a sync route', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/', (_, rep) => {
+    rep.status(501)
+
+    /* eslint-disable-next-line */
+    throw { foo: 'bar' }
+  })
+
+  // ----
+  const reply = await fastify.inject({ method: 'GET', url: '/' })
+  t.equal(reply.statusCode, 501)
+  t.equal(JSON.parse(reply.body).foo, 'bar')
+})
+
+test('should trigger error handlers if a sync route throws any non-error object', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', () => {
+    /* eslint-disable-next-line */
+    throw { foo: 'bar' }
+  })
+
+  fastify.setErrorHandler(async (error) => {
+    t.ok(error)
+    return error
+  })
+
+  // ----
+  const reply = await fastify.inject({ method: 'GET', url: '/' })
+  t.equal(reply.statusCode, 500)
+  t.equal(JSON.parse(reply.body).foo, 'bar')
+})

package/test/throw.test.js

@@ -71,6 +71,18 @@ test('Fastify should throw for an invalid schema, printing the error route - bod
   })
 })
 
+test('Fastify should throw for an invalid shorthand option type', t => {
+  t.plan(3)
+  try {
+    Fastify({ jsonShorthand: 'hello' })
+    t.fail()
+  } catch (e) {
+    t.equal(e.code, 'FST_ERR_INIT_OPTS_INVALID')
+    t.match(e.message, /should be boolean/)
+    t.pass()
+  }
+})
+
 test('Should throw on unsupported method', t => {
   t.plan(1)
   const fastify = Fastify()

package/test/types/fastify.test-d.ts

@@ -3,12 +3,15 @@ import fastify, {
   FastifyInstance,
   FastifyPlugin,
   FastifyPluginAsync,
-  FastifyPluginCallback
+  FastifyPluginCallback,
+  LightMyRequestChain,
+  LightMyRequestResponse,
+  LightMyRequestCallback,
+  InjectOptions
 } from '../../fastify'
 import * as http from 'http'
 import * as https from 'https'
 import * as http2 from 'http2'
-import { Chain as LightMyRequestChain } from 'light-my-request'
 import { expectType, expectError, expectAssignable } from 'tsd'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { Socket } from 'net'
@@ -21,12 +24,20 @@ expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerRespons
 expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: {} }))
 // http2 server
 expectType<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse> & PromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, http2SessionTimeout: 1000 }))
-expectType<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> & PromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, https: {} }))
+expectType<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> & PromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 }))
 expectType<LightMyRequestChain>(fastify({ http2: true, https: {} }).inject())
 
 expectError(fastify<http2.Http2Server>({ http2: false })) // http2 option must be true
 expectError(fastify<http2.Http2SecureServer>({ http2: false })) // http2 option must be true
 
+// light-my-request
+expectAssignable<InjectOptions>({ query: '' })
+fastify({ http2: true, https: {} }).inject().then((resp) => {
+  expectAssignable<LightMyRequestResponse>(resp)
+})
+const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {}
+fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
+
 // server options
 expectAssignable<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>(fastify({ http2: true }))
 expectAssignable<FastifyInstance>(fastify({ ignoreTrailingSlash: true }))