fastify 4.2.1 → 4.3.0

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

@@ -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.1",
+  "version": "4.3.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

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)