fastify 4.0.0 → 4.0.3

package/lib/error-serializer.js

@@ -1,195 +1,191 @@
 // This file is autogenerated by build/build-error-serializer.js, do not edit
 /* istanbul ignore file */
-module.exports = $main
-    'use strict'
-  
-    
-function $pad2Zeros (num) {
-  const s = '00' + num
-  return s[s.length - 2] + s[s.length - 1]
-}
 
-function $asAny (i) {
-  return JSON.stringify(i)
-}
+  'use strict'
 
-function $asNull () {
-  return 'null'
-}
+  
 
-function $asInteger (i) {
-  if (typeof i === 'bigint') {
-    return i.toString()
-  } else if (Number.isInteger(i)) {
-    return $asNumber(i)
-  } else {
-    /* eslint no-undef: "off" */
-    return $asNumber(parseInteger(i))
+class Serializer {
+  constructor (options = {}) {
+    switch (options.rounding) {
+      case 'floor':
+        this.parseInteger = Math.floor
+        break
+      case 'ceil':
+        this.parseInteger = Math.ceil
+        break
+      case 'round':
+        this.parseInteger = Math.round
+        break
+      default:
+        this.parseInteger = Math.trunc
+        break
+    }
   }
-}
 
-function $asIntegerNullable (i) {
-  return i === null ? null : $asInteger(i)
-}
+  asAny (i) {
+    return JSON.stringify(i)
+  }
 
-function $asNumber (i) {
-  const num = Number(i)
-  if (isNaN(num)) {
+  asNull () {
     return 'null'
-  } else {
-    return '' + num
   }
-}
 
-function $asNumberNullable (i) {
-  return i === null ? null : $asNumber(i)
-}
+  asInteger (i) {
+    if (typeof i === 'bigint') {
+      return i.toString()
+    } else if (Number.isInteger(i)) {
+      return '' + i
+    } else {
+      /* eslint no-undef: "off" */
+      const integer = this.parseInteger(i)
+      if (Number.isNaN(integer)) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      } else {
+        return '' + integer
+      }
+    }
+  }
 
-function $asBoolean (bool) {
-  return bool && 'true' || 'false' // eslint-disable-line
-}
+  asIntegerNullable (i) {
+    return i === null ? 'null' : this.asInteger(i)
+  }
 
-function $asBooleanNullable (bool) {
-  return bool === null ? null : $asBoolean(bool)
-}
+  asNumber (i) {
+    const num = Number(i)
+    if (Number.isNaN(num)) {
+      throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else {
+      return '' + num
+    }
+  }
 
-function $asDatetime (date, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (date instanceof Date) {
-    return quotes + date.toISOString() + quotes
-  } else if (date && typeof date.toISOString === 'function') {
-    return quotes + date.toISOString() + quotes
-  } else {
-    return $asString(date, skipQuotes)
+  asNumberNullable (i) {
+    return i === null ? 'null' : this.asNumber(i)
   }
-}
 
-function $asDate (date, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (date instanceof Date) {
-    return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000 )).toISOString().slice(0, 10) + quotes
-  } else if (date && typeof date.format === 'function') {
-    return quotes + date.format('YYYY-MM-DD') + quotes
-  } else {
-    return $asString(date, skipQuotes)
+  asBoolean (bool) {
+    return bool && 'true' || 'false' // eslint-disable-line
   }
-}
 
-function $asTime (date, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (date instanceof Date) {
-    const hour = new Intl.DateTimeFormat('en', { hour: 'numeric', hour12: false }).format(date)
-    const minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
-    const second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
-    return quotes + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + quotes
-  } else if (date && typeof date.format === 'function') {
-    return quotes + date.format('HH:mm:ss') + quotes
-  } else {
-    return $asString(date, skipQuotes)
+  asBooleanNullable (bool) {
+    return bool === null ? 'null' : this.asBoolean(bool)
   }
-}
 
-function $asString (str, skipQuotes) {
-  const quotes = skipQuotes === true ? '' : '"'
-  if (str instanceof Date) {
-    return quotes + str.toISOString() + quotes
-  } else if (str === null) {
-    return quotes + quotes
-  } else if (str instanceof RegExp) {
-    str = str.source
-  } else if (typeof str !== 'string') {
-    str = str.toString()
+  asDatetime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + date.toISOString() + quotes
+    }
+    return this.asString(date, skipQuotes)
   }
-  // If we skipQuotes it means that we are using it as test
-  // no need to test the string length for the render
-  if (skipQuotes) {
-    return str
+
+  asDatetimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
   }
 
-  if (str.length < 42) {
-    return $asStringSmall(str)
-  } else {
-    return JSON.stringify(str)
+  asDate (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+    }
+    return this.asString(date, skipQuotes)
   }
-}
 
-function $asStringNullable (str) {
-  return str === null ? null : $asString(str)
-}
+  asDateNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDate(date, skipQuotes)
+  }
 
-// magically escape strings for json
-// relying on their charCodeAt
-// everything below 32 needs JSON.stringify()
-// every string that contain surrogate needs JSON.stringify()
-// 34 and 92 happens all the time, so we
-// have a fast case for them
-function $asStringSmall (str) {
-  const l = str.length
-  let result = ''
-  let last = 0
-  let found = false
-  let surrogateFound = false
-  let point = 255
-  // eslint-disable-next-line
-  for (var i = 0; i < l && point >= 32; i++) {
-    point = str.charCodeAt(i)
-    if (point >= 0xD800 && point <= 0xDFFF) {
-      // The current character is a surrogate.
-      surrogateFound = true
-    }
-    if (point === 34 || point === 92) {
-      result += str.slice(last, i) + '\\'
-      last = i
-      found = true
+  asTime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
     }
+    return this.asString(date, skipQuotes)
   }
 
-  if (!found) {
-    result = str
-  } else {
-    result += str.slice(last)
+  asTimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asTime(date, skipQuotes)
   }
-  return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
-}
 
+  asString (str, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (str instanceof Date) {
+      return quotes + str.toISOString() + quotes
+    } else if (str === null) {
+      return quotes + quotes
+    } else if (str instanceof RegExp) {
+      str = str.source
+    } else if (typeof str !== 'string') {
+      str = str.toString()
+    }
+    // If we skipQuotes it means that we are using it as test
+    // no need to test the string length for the render
+    if (skipQuotes) {
+      return str
+    }
 
-    
-    /**
-     * Used by schemas that are dependant on calling 'ajv.validate' during runtime,
-     * it stores the value of the '$id' property of the schema (if it has it) inside
-     * a cache which is used to figure out if the schema was compiled into a validator
-     * by ajv on a previous call, if it was then the '$id' string will be used to 
-     * invoke 'ajv.validate', this allows:
-     * 
-     * 1. Schemas that depend on ajv.validate calls to leverage ajv caching system.
-     * 2. To avoid errors, since directly invoking 'ajv.validate' with the same 
-     * schema (that contains an '$id' property) twice will throw an error.
-     */
-    const $validateWithAjv = (function() {
-      const cache = new Set()
-
-      return function (schema, target) {
-        const id = schema.$id
-        
-        if (!id) {
-          return ajv.validate(schema, target)
-        }
+    if (str.length < 42) {
+      return this.asStringSmall(str)
+    } else {
+      return JSON.stringify(str)
+    }
+  }
 
-        const cached = cache.has(id)
+  asStringNullable (str) {
+    return str === null ? 'null' : this.asString(str)
+  }
 
-        if (cached) {
-          return ajv.validate(id, target)
-        } else {
-          cache.add(id)
-          return ajv.validate(schema, target)
-        }
+  // magically escape strings for json
+  // relying on their charCodeAt
+  // everything below 32 needs JSON.stringify()
+  // every string that contain surrogate needs JSON.stringify()
+  // 34 and 92 happens all the time, so we
+  // have a fast case for them
+  asStringSmall (str) {
+    const l = str.length
+    let result = ''
+    let last = 0
+    let found = false
+    let surrogateFound = false
+    let point = 255
+    // eslint-disable-next-line
+    for (var i = 0; i < l && point >= 32; i++) {
+      point = str.charCodeAt(i)
+      if (point >= 0xD800 && point <= 0xDFFF) {
+        // The current character is a surrogate.
+        surrogateFound = true
       }
-    })()
+      if (point === 34 || point === 92) {
+        result += str.slice(last, i) + '\\'
+        last = i
+        found = true
+      }
+    }
+
+    if (!found) {
+      result = str
+    } else {
+      result += str.slice(last)
+    }
+    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+  }
+}
 
+  
+
+  const serializer = new Serializer({"mode":"standalone"})
+  
 
-    function parseInteger(int) { return Math.trunc(int) }
+  
+    function main (input) {
+      let json = ''
+      json += anonymous0(input)
+      return json
+    }
     
-    function $main (input) {
+    function anonymous0 (input) {
+      // main
   
       var obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()
@@ -198,60 +194,60 @@ function $asStringSmall (str) {
       var json = '{'
       var addComma = false
   
-          var t = Number(obj["statusCode"])
-          if (!isNaN(t)) {
-            
+      if (obj["statusCode"] !== undefined) {
+        
   if (addComma) {
     json += ','
   } else {
     addComma = true
   }
 
-            json += "\"statusCode\"" + ':' + t
-      
+        json += "\"statusCode\"" + ':'
+      json += serializer.asNumber.bind(serializer)(obj["statusCode"])
       }
     
-        if (obj["code"] !== undefined) {
-          
+      if (obj["code"] !== undefined) {
+        
   if (addComma) {
     json += ','
   } else {
     addComma = true
   }
 
-          json += "\"code\"" + ':'
-        json += $asString(obj["code"])
+        json += "\"code\"" + ':'
+      json += serializer.asString.bind(serializer)(obj["code"])
       }
     
-        if (obj["error"] !== undefined) {
-          
+      if (obj["error"] !== undefined) {
+        
   if (addComma) {
     json += ','
   } else {
     addComma = true
   }
 
-          json += "\"error\"" + ':'
-        json += $asString(obj["error"])
+        json += "\"error\"" + ':'
+      json += serializer.asString.bind(serializer)(obj["error"])
       }
     
-        if (obj["message"] !== undefined) {
-          
+      if (obj["message"] !== undefined) {
+        
   if (addComma) {
     json += ','
   } else {
     addComma = true
   }
 
-          json += "\"message\"" + ':'
-        json += $asString(obj["message"])
+        json += "\"message\"" + ':'
+      json += serializer.asString.bind(serializer)(obj["message"])
       }
     
       json += '}'
       return json
     }
-    
-  
-    ;
-     return $main
   
+    
+    
+
+  module.exports = main
+      

package/lib/pluginUtils.js

@@ -104,7 +104,17 @@ function checkVersion (fn) {
   const requiredVersion = meta.fastify
 
   const fastifyRc = /-rc.+$/.test(this.version)
+  if (fastifyRc === true && semver.gt(this.version, semver.coerce(requiredVersion)) === true) {
+    // A Fastify release candidate phase is taking place. In order to reduce
+    // the effort needed to test plugins with the RC, we allow plugins targeting
+    // the prior Fastify release to be loaded.
+    return
+  }
   if (requiredVersion && semver.satisfies(this.version, requiredVersion, { includePrerelease: fastifyRc }) === false) {
+    // We are not in a release candidate phase. Thus, we must honor the semver
+    // ranges defined by the plugin's metadata. Which is to say, if the plugin
+    // expects an older version of Fastify than the _current_ version, we will
+    // throw an error.
     throw new FST_ERR_PLUGIN_VERSION_MISMATCH(meta.name, requiredVersion, this.version)
   }
 }

package/lib/reply.js

@@ -291,7 +291,7 @@ Reply.prototype.removeTrailer = function (key) {
 
 Reply.prototype.code = function (code) {
   const intValue = parseInt(code)
-  if (isNaN(intValue) || intValue < 100 || intValue > 600) {
+  if (isNaN(intValue) || intValue < 100 || intValue > 599) {
     throw new FST_ERR_BAD_STATUS_CODE(code || String(code))
   }
 

package/lib/server.js

@@ -41,7 +41,15 @@ function createServer (options, httpHandler) {
       listenOptions.cb = cb
     }
 
-    const { host = 'localhost' } = listenOptions
+    // If we have a path specified, don't default host to 'localhost' so we don't end up listening
+    // on both path and host
+    // See https://github.com/fastify/fastify/issues/4007
+    let host
+    if (listenOptions.path == null) {
+      host = listenOptions.host ?? 'localhost'
+    } else {
+      host = listenOptions.host
+    }
     if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
       listenOptions.host = host
     }

package/lib/wrapThenable.js

@@ -11,9 +11,14 @@ function wrapThenable (thenable, reply) {
       return
     }
 
-    // this is for async functions that
-    // are using reply.send directly
-    if (payload !== undefined || reply.sent === false) {
+    // this is for async functions that are using reply.send directly
+    //
+    // since wrap-thenable will be called when using reply.send directly
+    // without actual return. the response can be sent already or
+    // the request may be terminated during the reply. in this situation,
+    // it require an extra checking of request.aborted to see whether
+    // the request is killed by client.
+    if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
       // we use a try-catch internally to avoid adding a catch to another
       // promise, increase promise perf by 10%
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.0.0",
+  "version": "4.0.3",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -12,11 +12,12 @@
     "coverage:ci": "npm run unit -- --cov --coverage-report=html --no-browser --no-check-coverage -R terse",
     "coverage:ci-check-coverage": "nyc check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
     "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\"",
-    "lint": "npm run lint:standard && npm run lint:typescript",
+    "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
     "lint:fix": "standard --fix",
+    "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "prepublishOnly": "tap --no-check-coverage test/internals/version.test.js",
+    "prepublishOnly": "tap --no-check-coverage test/build/**.test.js",
     "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- -R terse --cov --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
@@ -145,7 +146,7 @@
     "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
-    "fast-json-stringify": "^4.0.0",
+    "fast-json-stringify": "^4.2.0",
     "fastify-plugin": "^3.0.1",
     "fluent-json-schema": "^3.1.0",
     "form-data": "^4.0.0",
@@ -158,6 +159,7 @@
     "json-schema-to-ts": "^2.5.3",
     "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
+    "markdownlint-cli2": "^0.4.0",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "self-cert": "^2.0.0",
@@ -168,7 +170,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0-2",
     "tap": "^16.2.0",
-    "tsd": "^0.20.0",
+    "tsd": "^0.21.0",
     "typescript": "^4.7.2",
     "undici": "^5.4.0",
     "x-xss-protection": "^2.0.0",
@@ -177,7 +179,7 @@
   "dependencies": {
     "@fastify/ajv-compiler": "^3.1.0",
     "@fastify/error": "^3.0.0",
-    "@fastify/fast-json-stringify-compiler": "^3.0.0",
+    "@fastify/fast-json-stringify-compiler": "^3.0.1",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.1.3",
     "find-my-way": "^6.3.0",

package/test/build/error-serializer.test.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fs = require('fs')
+const path = require('path')
+
+const { code } = require('../../build/build-error-serializer')
+
+test('check generated code syntax', async (t) => {
+  t.plan(1)
+
+  // standard is a esm, we import it like this
+  const { default: standard } = await import('standard')
+  const result = await standard.lintText(code)
+
+  // if there are any invalid syntax
+  // fatal count will be greater than 0
+  t.equal(result[0].fatalErrorCount, 0)
+})
+
+test('ensure the current error serializer is latest', async (t) => {
+  t.plan(1)
+
+  const current = await fs.promises.readFile(path.resolve('lib/error-serializer.js'))
+
+  t.equal(current.toString(), code)
+})

package/test/{internals → build}/version.test.js

@@ -4,7 +4,7 @@ const fs = require('fs')
 const path = require('path')
 const t = require('tap')
 const test = t.test
-const fastify = require('../..')()
+const fastify = require('../../fastify')()
 
 test('should be the same as package.json', t => {
   t.plan(1)

package/test/listen.test.js

@@ -196,14 +196,28 @@ if (os.platform() !== 'win32') {
     const fastify = Fastify()
     t.teardown(fastify.close.bind(fastify))
 
-    const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').substr(2, 8)}-server.sock`)
+    const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').slice(2, 10)}-server.sock`)
     try {
       fs.unlinkSync(sockFile)
     } catch (e) { }
 
     fastify.listen({ path: sockFile }, (err, address) => {
       t.error(err)
-      t.equal(sockFile, fastify.server.address())
+      t.strictSame(fastify.addresses(), [sockFile])
+      t.equal(address, sockFile)
+    })
+  })
+} else {
+  test('listen on socket', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    t.teardown(fastify.close.bind(fastify))
+
+    const sockFile = `\\\\.\\pipe\\${(Math.random().toString(16) + '0000000').slice(2, 10)}-server-sock`
+
+    fastify.listen({ path: sockFile }, (err, address) => {
+      t.error(err)
+      t.strictSame(fastify.addresses(), [sockFile])
       t.equal(address, sockFile)
     })
   })

package/test/plugin.test.js

@@ -1057,6 +1057,38 @@ test('plugin metadata - release candidate', t => {
   }
 })
 
+test('fastify-rc loads prior version plugins', t => {
+  t.plan(2)
+  const fastify = Fastify()
+  Object.defineProperty(fastify, 'version', {
+    value: '99.0.0-rc.1'
+  })
+
+  plugin[Symbol.for('plugin-meta')] = {
+    name: 'plugin',
+    fastify: '^98.1.0'
+  }
+  plugin2[Symbol.for('plugin-meta')] = {
+    name: 'plugin2',
+    fastify: '98.x'
+  }
+
+  fastify.register(plugin)
+
+  fastify.ready((err) => {
+    t.error(err)
+    t.pass('everything right')
+  })
+
+  function plugin (instance, opts, done) {
+    done()
+  }
+
+  function plugin2 (instance, opts, done) {
+    done()
+  }
+})
+
 test('hasPlugin method exists as a function', t => {
   t.plan(1)
 

package/test/reply-error.test.js

@@ -520,7 +520,13 @@ const invalidErrorCodes = [
   undefined,
   null,
   'error_code',
-  700 // out of the 100-600 range
+
+  // out of the 100-599 range:
+  0,
+  1,
+  99,
+  600,
+  700
 ]
 invalidErrorCodes.forEach((invalidCode) => {
   test(`should throw error if error code is ${invalidCode}`, t => {