feat: Add allowUndeclaredResponses option.

Author: ShogunPanda

README.md

@@ -24,6 +24,7 @@ Register as a plugin, optional providing any of the following options:
 - `hideUnhandledErrors`: If to hide unhandled server errors or returning to the client including stack information. Default is to hide errors when `NODE_ENV` environment variable is `production`.
 - `convertValidationErrors`: Convert validation errors to a structured human readable object. Default is `true`.
 - `convertResponsesValidationErrors`: Convert response validation errors to a structured human readable object. Default is to enable when `NODE_ENV` environment variable is different from `production`.
+- `allowUndeclaredResponses`: When converting response validation errors, allow responses that have no schema defined instead of throwing an error.
 
 Once registered, the server will use the plugin handlers for all errors (basically, both `setErrorHandler` and `setNotFoundHandler` are called).
 
@@ -49,7 +50,7 @@ const createError = require('http-errors')
 server.register(require('fastify-errors-properties'))
 
 server.get('/invalid', {
-  handler: async function(request, reply) {
+  async handler(request, reply) {
     throw createError(404, 'You are not supposed to reach this.', { header: { 'X-Req-Id': request.id, id: 123 } })
   }
 })
@@ -101,7 +102,7 @@ const createError = require('http-errors')
 server.register(require('fastify-errors-properties'), { hideUnhandledErrors: false })
 
 server.get('/invalid', {
-  handler: function(request, reply) {
+  handler(request, reply) {
     const error = new Error('This was not supposed to happen.')
     error.id = 123
     throw error

lib/index.js

@@ -28,12 +28,17 @@ Object.defineProperty(exports, "convertValidationErrors", { enumerable: true, ge
 Object.defineProperty(exports, "niceJoin", { enumerable: true, get: function () { return validation_2.niceJoin; } });
 Object.defineProperty(exports, "validationMessagesFormatters", { enumerable: true, get: function () { return validation_2.validationMessagesFormatters; } });
 exports.plugin = fastify_plugin_1.default(function (instance, options, done) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const isProduction = process.env.NODE_ENV === 'production';
     const hideUnhandledErrors = (_a = options.hideUnhandledErrors) !== null && _a !== void 0 ? _a : isProduction;
     const convertValidationErrors = (_b = options.convertValidationErrors) !== null && _b !== void 0 ? _b : true;
     const convertResponsesValidationErrors = (_c = options.convertResponsesValidationErrors) !== null && _c !== void 0 ? _c : !isProduction;
-    instance.decorateRequest('errorProperties', { hideUnhandledErrors, convertValidationErrors });
+    const allowUndeclaredResponses = (_d = options.allowUndeclaredResponses) !== null && _d !== void 0 ? _d : false;
+    instance.decorateRequest('errorProperties', {
+        hideUnhandledErrors,
+        convertValidationErrors,
+        allowUndeclaredResponses
+    });
     instance.setErrorHandler(handlers_1.handleErrors);
     instance.setNotFoundHandler(handlers_1.handleNotFoundError);
     if (convertResponsesValidationErrors) {

lib/validation.js

@@ -174,7 +174,7 @@ function addResponseValidation(route) {
         validators[code] = this.responseValidatorSchemaCompiler.compile(schema);
     }
     // Note that this hook is not called for non JSON payloads therefore validation is not possible in such cases
-    route.preSerialization = async function (_request, reply, payload) {
+    route.preSerialization = async function (request, reply, payload) {
         const statusCode = reply.raw.statusCode;
         // Never validate error 500
         if (statusCode === http_status_codes_1.default.INTERNAL_SERVER_ERROR) {
@@ -183,6 +183,9 @@ function addResponseValidation(route) {
         // No validator, it means the HTTP status is not allowed
         const validator = validators[statusCode];
         if (!validator) {
+            if (request.errorProperties.allowUndeclaredResponses) {
+                return payload;
+            }
             throw http_errors_1.default(http_status_codes_1.default.INTERNAL_SERVER_ERROR, exports.validationMessagesFormatters.invalidResponseCode(statusCode));
         }
         // Now validate the payload

src/index.ts

@@ -15,8 +15,13 @@ export const plugin = fastifyPlugin(
     const hideUnhandledErrors = options.hideUnhandledErrors ?? isProduction
     const convertValidationErrors = options.convertValidationErrors ?? true
     const convertResponsesValidationErrors = options.convertResponsesValidationErrors ?? !isProduction
+    const allowUndeclaredResponses = options.allowUndeclaredResponses ?? false
 
-    instance.decorateRequest('errorProperties', { hideUnhandledErrors, convertValidationErrors })
+    instance.decorateRequest('errorProperties', {
+      hideUnhandledErrors,
+      convertValidationErrors,
+      allowUndeclaredResponses
+    })
     instance.setErrorHandler(handleErrors)
     instance.setNotFoundHandler(handleNotFoundError)
 

src/interfaces.ts

@@ -9,6 +9,7 @@ declare module 'fastify' {
     errorProperties?: {
       hideUnhandledErrors?: boolean
       convertValidationErrors?: boolean
+      allowUndeclaredResponses?: boolean
     }
   }
 

src/validation.ts

@@ -202,7 +202,7 @@ export function addResponseValidation(this: FastifyInstance, route: RouteOptions
   // Note that this hook is not called for non JSON payloads therefore validation is not possible in such cases
   route.preSerialization = async function (
     this: FastifyInstance,
-    _request: FastifyRequest,
+    request: FastifyRequest,
     reply: FastifyReply,
     payload: any
   ): Promise<any> {
@@ -217,6 +217,10 @@ export function addResponseValidation(this: FastifyInstance, route: RouteOptions
     const validator = validators[statusCode]
 
     if (!validator) {
+      if (request.errorProperties!.allowUndeclaredResponses) {
+        return payload
+      }
+
       throw createError(StatusCodes.INTERNAL_SERVER_ERROR, validationMessagesFormatters.invalidResponseCode(statusCode))
     }
 

test/validation.test.ts

@@ -80,6 +80,30 @@ async function buildServer(options: FastifyPluginOptions = {}): Promise<FastifyI
     }
   })
 
+  server.get('/undeclared-response', {
+    schema: {
+      response: {
+        [StatusCodes.OK]: {
+          type: 'object',
+          properties: {
+            a: {
+              type: 'string'
+            },
+            b: {
+              type: 'string'
+            }
+          },
+          required: ['b'],
+          additionalProperties: false
+        }
+      }
+    },
+    async handler(_r: FastifyRequest, reply: FastifyReply): Promise<object> {
+      reply.code(StatusCodes.ACCEPTED)
+      return { a: 1 }
+    }
+  })
+
   server.get('/no-json', {
     schema: {
       response: {
@@ -411,6 +435,15 @@ t.test('Response Validation', (t: Test) => {
     t.deepEqual(JSON.parse(response.payload), { a: 1, c: 2 })
   })
 
+  t.test('should allow responses which are missing in the schema if explicitily enabled', async (t: Test) => {
+    await buildServer({ allowUndeclaredResponses: true })
+
+    const response = await server!.inject({ method: 'GET', url: '/undeclared-response' })
+
+    t.equal(response.statusCode, StatusCodes.ACCEPTED)
+    t.deepEqual(JSON.parse(response.payload), { a: 1 })
+  })
+
   t.test('should allow everything if the payload is not JSON', async (t: Test) => {
     await buildServer()
 

types/interfaces.d.ts

@@ -8,6 +8,7 @@ declare module 'fastify' {
         errorProperties?: {
             hideUnhandledErrors?: boolean;
             convertValidationErrors?: boolean;
+            allowUndeclaredResponses?: boolean;
         };
     }
     interface FastifyReply {