fastify 4.2.0 → 4.4.0

package/lib/reply.js

@@ -16,7 +16,11 @@ const {
   kReplyHasStatusCode,
   kReplyIsRunningOnErrorHook,
   kReplyNextErrorHandler,
-  kDisableRequestLogging
+  kDisableRequestLogging,
+  kSchemaResponse,
+  kReplySerializeWeakMap,
+  kSchemaController,
+  kOptions
 } = require('./symbols.js')
 const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
 
@@ -38,7 +42,8 @@ const {
   FST_ERR_SEND_INSIDE_ONERR,
   FST_ERR_BAD_STATUS_CODE,
   FST_ERR_BAD_TRAILER_NAME,
-  FST_ERR_BAD_TRAILER_VALUE
+  FST_ERR_BAD_TRAILER_VALUE,
+  FST_ERR_MISSING_SERIALIZATION_FN
 } = require('./errors')
 const warning = require('./warnings')
 
@@ -203,10 +208,8 @@ Reply.prototype.getHeaders = function () {
 
 Reply.prototype.hasHeader = function (key) {
   key = key.toLowerCase()
-  if (this[kReplyHeaders][key] !== undefined) {
-    return true
-  }
-  return this.raw.hasHeader(key)
+
+  return this[kReplyHeaders][key] !== undefined || this.raw.hasHeader(key)
 }
 
 Reply.prototype.removeHeader = function (key) {
@@ -216,25 +219,24 @@ Reply.prototype.removeHeader = function (key) {
   return this
 }
 
-Reply.prototype.header = function (key, value) {
-  const _key = key.toLowerCase()
-
-  // default the value to ''
-  value = value === undefined ? '' : value
+Reply.prototype.header = function (key, value = '') {
+  key = key.toLowerCase()
 
-  if (this[kReplyHeaders][_key] && _key === 'set-cookie') {
+  if (this[kReplyHeaders][key] && key === 'set-cookie') {
     // https://tools.ietf.org/html/rfc7230#section-3.2.2
-    if (typeof this[kReplyHeaders][_key] === 'string') {
-      this[kReplyHeaders][_key] = [this[kReplyHeaders][_key]]
+    if (typeof this[kReplyHeaders][key] === 'string') {
+      this[kReplyHeaders][key] = [this[kReplyHeaders][key]]
     }
+
     if (Array.isArray(value)) {
-      Array.prototype.push.apply(this[kReplyHeaders][_key], value)
+      this[kReplyHeaders][key].push(...value)
     } else {
-      this[kReplyHeaders][_key].push(value)
+      this[kReplyHeaders][key].push(value)
     }
   } else {
-    this[kReplyHeaders][_key] = value
+    this[kReplyHeaders][key] = value
   }
+
   return this
 }
 
@@ -245,6 +247,7 @@ Reply.prototype.headers = function (headers) {
     const key = keys[i]
     this.header(key, headers[key])
   }
+
   return this
 }
 
@@ -279,8 +282,7 @@ Reply.prototype.trailer = function (key, fn) {
 }
 
 Reply.prototype.hasTrailer = function (key) {
-  if (this[kReplyTrailers] === null) return false
-  return this[kReplyTrailers][key.toLowerCase()] !== undefined
+  return this[kReplyTrailers]?.[key.toLowerCase()] !== undefined
 }
 
 Reply.prototype.removeTrailer = function (key) {
@@ -302,6 +304,79 @@ Reply.prototype.code = function (code) {
 
 Reply.prototype.status = Reply.prototype.code
 
+Reply.prototype.getSerializationFunction = function (schemaOrStatus) {
+  let serialize
+
+  if (typeof schemaOrStatus === 'string' || typeof schemaOrStatus === 'number') {
+    serialize = this.context[kSchemaResponse]?.[schemaOrStatus]
+  } else if (typeof schemaOrStatus === 'object') {
+    serialize = this.context[kReplySerializeWeakMap]?.get(schemaOrStatus)
+  }
+
+  return serialize
+}
+
+Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null) {
+  const { request } = this
+  const { method, url } = request
+
+  // Check if serialize function already compiled
+  if (this.context[kReplySerializeWeakMap]?.has(schema)) {
+    return this.context[kReplySerializeWeakMap].get(schema)
+  }
+
+  const serializerCompiler = this.context.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,
+    method,
+    url,
+    httpStatus
+  })
+
+  // We create a WeakMap to compile the schema only once
+  // Its done leazily to avoid add overhead by creating the WeakMap
+  // if it is not used
+  // TODO: Explore a central cache for all the schemas shared across
+  // encapsulated contexts
+  if (this.context[kReplySerializeWeakMap] == null) {
+    this.context[kReplySerializeWeakMap] = new WeakMap()
+  }
+
+  this.context[kReplySerializeWeakMap].set(schema, serializeFn)
+
+  return serializeFn
+}
+
+Reply.prototype.serializeInput = function (input, schema, httpStatus) {
+  let serialize
+  httpStatus = typeof schema === 'string' || typeof schema === 'number'
+    ? schema
+    : httpStatus
+
+  if (httpStatus != null) {
+    serialize = this.context[kSchemaResponse]?.[httpStatus]
+
+    if (serialize == null) throw new FST_ERR_MISSING_SERIALIZATION_FN(httpStatus)
+  } else {
+    // Check if serialize function already compiled
+    if (this.context[kReplySerializeWeakMap]?.has(schema)) {
+      serialize = this.context[kReplySerializeWeakMap].get(schema)
+    } else {
+      serialize = this.compileSerializationSchema(schema, httpStatus)
+    }
+  }
+
+  return serialize(input)
+}
+
 Reply.prototype.serialize = function (payload) {
   if (this[kReplySerializer] !== null) {
     return this[kReplySerializer](payload)
@@ -330,8 +405,7 @@ Reply.prototype.redirect = function (code, url) {
     code = this[kReplyHasStatusCode] ? this.raw.statusCode : 302
   }
 
-  this.header('location', url).code(code).send()
-  return this
+  return this.header('location', url).code(code).send()
 }
 
 Reply.prototype.callNotFound = function () {
@@ -485,9 +559,12 @@ function onSendEnd (reply, payload) {
   }
 
   if (reply[kReplyTrailers] === null) {
-    if (!reply[kReplyHeaders]['content-length']) {
-      reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
-    } else if (req.raw.method !== 'HEAD' && reply[kReplyHeaders]['content-length'] !== Buffer.byteLength(payload)) {
+    const contentLength = reply[kReplyHeaders]['content-length']
+    if (!contentLength ||
+        (req.raw.method !== 'HEAD' &&
+         parseInt(contentLength, 10) !== Buffer.byteLength(payload)
+        )
+    ) {
       reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
     }
   }

package/lib/request.js

@@ -4,8 +4,24 @@ const proxyAddr = require('proxy-addr')
 const semver = require('semver')
 const warning = require('./warnings')
 const {
-  kHasBeenDecorated
+  kHasBeenDecorated,
+  kSchemaBody,
+  kSchemaHeaders,
+  kSchemaParams,
+  kSchemaQuerystring,
+  kSchemaController,
+  kOptions,
+  kRequestValidateWeakMap
 } = require('./symbols')
+const { FST_ERR_REQ_INVALID_VALIDATION_INVOCATION } = require('./errors')
+
+const HTTP_PART_SYMBOL_MAP = {
+  body: kSchemaBody,
+  headers: kSchemaHeaders,
+  params: kSchemaParams,
+  querystring: kSchemaQuerystring,
+  query: kSchemaQuerystring
+}
 
 function Request (id, params, req, query, log, context) {
   this.id = id
@@ -194,6 +210,86 @@ Object.defineProperties(Request.prototype, {
     set (headers) {
       this.additionalHeaders = headers
     }
+  },
+  getValidationFunction: {
+    value: function (httpPartOrSchema) {
+      if (typeof httpPartOrSchema === 'string') {
+        const symbol = HTTP_PART_SYMBOL_MAP[httpPartOrSchema]
+        return this.context[symbol]
+      } else if (typeof httpPartOrSchema === 'object') {
+        return this.context[kRequestValidateWeakMap]?.get(httpPartOrSchema)
+      }
+    }
+  },
+  compileValidationSchema: {
+    value: function (schema, httpPart = null) {
+      const { method, url } = this
+
+      if (this.context[kRequestValidateWeakMap]?.has(schema)) {
+        return this.context[kRequestValidateWeakMap].get(schema)
+      }
+
+      const validatorCompiler = this.context.validatorCompiler ||
+      this.server[kSchemaController].validatorCompiler ||
+     (
+       // We compile the schemas if no custom validatorCompiler is provided
+       // nor set
+       this.server[kSchemaController].setupValidator(this.server[kOptions]) ||
+       this.server[kSchemaController].validatorCompiler
+     )
+
+      const validateFn = validatorCompiler({
+        schema,
+        method,
+        url,
+        httpPart
+      })
+
+      // We create a WeakMap to compile the schema only once
+      // Its done leazily to avoid add overhead by creating the WeakMap
+      // if it is not used
+      // TODO: Explore a central cache for all the schemas shared across
+      // encapsulated contexts
+      if (this.context[kRequestValidateWeakMap] == null) {
+        this.context[kRequestValidateWeakMap] = new WeakMap()
+      }
+
+      this.context[kRequestValidateWeakMap].set(schema, validateFn)
+
+      return validateFn
+    }
+  },
+  validateInput: {
+    value: function (input, schema, httpPart) {
+      httpPart = typeof schema === 'string' ? schema : httpPart
+
+      const symbol = (httpPart != null && typeof httpPart === 'string') && HTTP_PART_SYMBOL_MAP[httpPart]
+      let validate
+
+      if (symbol) {
+        // Validate using the HTTP Request Part schema
+        validate = this.context[symbol]
+      }
+
+      // We cannot compile if the schema is missed
+      if (validate == null && (schema == null ||
+          typeof schema !== 'object' ||
+          Array.isArray(schema))
+      ) {
+        throw new FST_ERR_REQ_INVALID_VALIDATION_INVOCATION(httpPart)
+      }
+
+      if (validate == null) {
+        if (this.context[kRequestValidateWeakMap]?.has(schema)) {
+          validate = this.context[kRequestValidateWeakMap].get(schema)
+        } else {
+          // We proceed to compile if there's no validate function yet
+          validate = this.compileValidationSchema(schema, httpPart)
+        }
+      }
+
+      return validate(input)
+    }
   }
 })
 

package/lib/route.js

@@ -4,7 +4,7 @@ const FindMyWay = require('find-my-way')
 const Context = require('./context')
 const handleRequest = require('./handleRequest')
 const { hookRunner, hookIterator, lifecycleHooks } = require('./hooks')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('./httpMethods')
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
 const warning = require('./warnings')
@@ -241,6 +241,8 @@ function buildRouting (options) {
         attachValidation: opts.attachValidation,
         schemaErrorFormatter: opts.schemaErrorFormatter,
         replySerializer: this[kReplySerializerDefault],
+        validatorCompiler: opts.validatorCompiler,
+        serializerCompiler: opts.serializerCompiler,
         server: this,
         isFastify
       })

package/lib/symbols.js

@@ -9,6 +9,12 @@ const keys = {
   kLogLevel: Symbol('fastify.logLevel'),
   kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
+  kContentTypeParser: Symbol('fastify.contentTypeParser'),
+  kState: Symbol('fastify.state'),
+  kOptions: Symbol('fastify.options'),
+  kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
+  kPluginNameChain: Symbol('fastify.pluginNameChain'),
+  // Schema
   kSchemaController: Symbol('fastify.schemaController'),
   kSchemaHeaders: Symbol('headers-schema'),
   kSchemaParams: Symbol('params-schema'),
@@ -16,17 +22,20 @@ const keys = {
   kSchemaBody: Symbol('body-schema'),
   kSchemaResponse: Symbol('response-schema'),
   kSchemaErrorFormatter: Symbol('fastify.schemaErrorFormatter'),
-  kReplySerializerDefault: Symbol('fastify.replySerializerDefault'),
-  kContentTypeParser: Symbol('fastify.contentTypeParser'),
-  kReply: Symbol('fastify.Reply'),
+  kSchemaVisited: Symbol('fastify.schemas.visited'),
+  // Request
   kRequest: Symbol('fastify.Request'),
+  kRequestValidateFns: Symbol('fastify.request.cache.validateFns'),
   kRequestPayloadStream: Symbol('fastify.RequestPayloadStream'),
   kRequestAcceptVersion: Symbol('fastify.RequestAcceptVersion'),
-  kCanSetNotFoundHandler: Symbol('fastify.canSetNotFoundHandler'),
+  // 404
   kFourOhFour: Symbol('fastify.404'),
+  kCanSetNotFoundHandler: Symbol('fastify.canSetNotFoundHandler'),
   kFourOhFourLevelInstance: Symbol('fastify.404LogLevelInstance'),
   kFourOhFourContext: Symbol('fastify.404ContextKey'),
   kDefaultJsonParse: Symbol('fastify.defaultJSONParse'),
+  // Reply
+  kReply: Symbol('fastify.Reply'),
   kReplySerializer: Symbol('fastify.reply.serializer'),
   kReplyIsError: Symbol('fastify.reply.isError'),
   kReplyHeaders: Symbol('fastify.reply.headers'),
@@ -38,11 +47,8 @@ const keys = {
   kReplyEndTime: Symbol('fastify.reply.endTime'),
   kReplyErrorHandlerCalled: Symbol('fastify.reply.errorHandlerCalled'),
   kReplyIsRunningOnErrorHook: Symbol('fastify.reply.isRunningOnErrorHook'),
-  kSchemaVisited: Symbol('fastify.schemas.visited'),
-  kState: Symbol('fastify.state'),
-  kOptions: Symbol('fastify.options'),
-  kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
-  kPluginNameChain: Symbol('fastify.pluginNameChain'),
+  kReplySerializerDefault: Symbol('fastify.replySerializerDefault'),
+  kReplySerializeWeakMap: Symbol('fastify.reply.cache.serializeFns'),
   // 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'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -17,7 +17,7 @@
     "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/build/**.test.js",
+    "prepublishOnly": "PREPUBLISH=true 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",
@@ -126,7 +126,7 @@
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.23.5",
+    "@sinclair/typebox": "^0.24.9",
     "@sinonjs/fake-timers": "^9.1.2",
     "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.27.0",
@@ -147,7 +147,7 @@
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
     "fast-json-stringify": "^5.0.0",
-    "fastify-plugin": "^3.0.1",
+    "fastify-plugin": "^4.0.0",
     "fluent-json-schema": "^3.1.0",
     "form-data": "^4.0.0",
     "frameguard": "^4.0.0",
@@ -159,7 +159,7 @@
     "json-schema-to-ts": "^2.5.3",
     "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
-    "markdownlint-cli2": "^0.4.0",
+    "markdownlint-cli2": "^0.5.0",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "self-cert": "^2.0.0",
@@ -170,14 +170,14 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0-2",
     "tap": "^16.2.0",
-    "tsd": "^0.21.0",
+    "tsd": "^0.22.0",
     "typescript": "^4.7.2",
     "undici": "^5.4.0",
     "x-xss-protection": "^2.0.0",
     "yup": "^0.32.11"
   },
   "dependencies": {
-    "@fastify/ajv-compiler": "^3.1.0",
+    "@fastify/ajv-compiler": "^3.1.1",
     "@fastify/error": "^3.0.0",
     "@fastify/fast-json-stringify-compiler": "^4.0.0",
     "abstract-logging": "^2.0.1",

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

@@ -23,7 +23,9 @@ test('check generated code syntax', async (t) => {
   t.equal(result[0].fatalErrorCount, 0)
 })
 
-test('ensure the current error serializer is latest', async (t) => {
+const isPrebublish = !!process.env.PREPUBLISH
+
+test('ensure the current error serializer is latest', { skip: !isPrebublish }, async (t) => {
   t.plan(1)
 
   const current = await fs.promises.readFile(path.resolve('lib/error-serializer.js'))

package/test/content-parser.test.js

@@ -58,6 +58,21 @@ test('getParser', t => {
     t.equal(fastify[keys.kContentTypeParser].getParser('text/html').fn, third)
   })
 
+  test('should return matching parser with caching', t => {
+    t.plan(6)
+
+    const fastify = Fastify()
+
+    fastify.addContentTypeParser('text/html', first)
+
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html').fn, first)
+    t.equal(fastify[keys.kContentTypeParser].cache.size, 0)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html ').fn, first)
+    t.equal(fastify[keys.kContentTypeParser].cache.size, 1)
+    t.equal(fastify[keys.kContentTypeParser].getParser('text/html ').fn, first)
+    t.equal(fastify[keys.kContentTypeParser].cache.size, 1)
+  })
+
   test('should prefer content type parser with string value', t => {
     t.plan(2)
 

package/test/copy.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - copy', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'COPY',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(204).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - copy', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+      method: 'COPY',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 204)
+    })
+  })
+})

package/test/internals/all.test.js

@@ -3,9 +3,15 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('../..')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('../../lib/httpMethods')
 
 test('fastify.all should add all the methods to the same url', t => {
+  const requirePayload = [
+    'POST',
+    'PUT',
+    'PATCH'
+  ]
+
   t.plan(supportedMethods.length * 2)
 
   const fastify = Fastify()
@@ -22,7 +28,7 @@ test('fastify.all should add all the methods to the same url', t => {
       method
     }
 
-    if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+    if (requirePayload.includes(method)) {
       options.payload = { hello: 'world' }
     }