Merge pull request #4 from ShogunPanda/undeclared-response

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).
 
@@ -105,7 +106,7 @@ const createError = require('http-errors')
 server.register(require('fastify-http-errors-enhanced'), { 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

@@ -25,12 +25,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

@@ -170,7 +170,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_errors_enhanced_1.INTERNAL_SERVER_ERROR) {
@@ -179,6 +179,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 new http_errors_enhanced_1.InternalServerError(exports.validationMessagesFormatters.invalidResponseCode(statusCode));
         }
         // Now validate the payload

src/index.ts

@@ -14,8 +14,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

@@ -201,7 +201,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> {
@@ -216,6 +216,10 @@ export function addResponseValidation(this: FastifyInstance, route: RouteOptions
     const validator = validators[statusCode]
 
     if (!validator) {
+      if (request.errorProperties!.allowUndeclaredResponses) {
+        return payload
+      }
+
       throw new InternalServerError(validationMessagesFormatters.invalidResponseCode(statusCode))
     }
 

test/validation.test.ts

@@ -80,6 +80,30 @@ async function buildServer(options: FastifyPluginOptions = {}): Promise<FastifyI
     }
   })
 
+  server.get('/undeclared-response', {
+    schema: {
+      response: {
+        [OK]: {
+          type: 'object',
+          properties: {
+            a: {
+              type: 'string'
+            },
+            b: {
+              type: 'string'
+            }
+          },
+          required: ['b'],
+          additionalProperties: false
+        }
+      }
+    },
+    async handler(_r: FastifyRequest, reply: FastifyReply): Promise<object> {
+      reply.code(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, 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;
         };
     }
 }