support multiple instances of the validator for multiple yaml files (#145)

Co-authored-by: manorlahagani <[email protected]>
Co-authored-by: Kobi Carmeli <[email protected]>
Co-authored-by: Igor Savin <[email protected]>

Author: 4 people

CHANGELOG.md

@@ -3,6 +3,11 @@
 ### Improvements
 - Update dependencies to address security vulnerabilities
 
+# 3.2.0 - 26 November, 2020
+
+### Features
+- Add getNewMiddleware which allow crating multiple-instances of the middleware #145
+
 # 3.1.1 - 2 September, 2020
 
 ### Fixes

README.md

@@ -28,6 +28,7 @@ There are no code changes in `[email protected]` compared to `e
     - [Express](#express)
     - [Koa](#koa)
     - [Fastify](#fastify)
+    - [Multiple-instances](#multiple-instances)
   - [Important Notes](#important-notes)
     - [Schema Objects](#schema-objects)
     - [Multipart/form-data (files)](#multipartform-data-files)
@@ -206,6 +207,21 @@ async function getApp() {
 }
 ```
 
+### multiple-instances
+```js
+const inputValidation = require('../../src/middleware');
+const validatorA = inputValidation.getNewMiddleware('test/pet-store-swaggerA.yaml', {framework: 'express'});
+const validatorB = inputValidation.getNewMiddleware('test/pet-store-swaggerB.yaml', {framework: 'express'});
+
+app.get('/pets', validatorA.validate, (req, res, next) => {
+    return res.json({ result: 'OK' });
+});
+
+app.post('/pets', validatorB.validate, (req, res, next) => {
+    return res.json({ result: 'OK' });
+});
+
+```
 ## Important Notes
 
 ### Schema Objects

package-lock.json

@@ -62,6 +62,7 @@
   "author": "Idan Tovi",
   "license": "Apache-2.0",
   "dependencies": {
+    "auto-bind": "^4.0.0",
     "api-schema-builder": "^2.0.4",
     "memoizee": "^0.4.14"
   },

package.json

@@ -1,106 +1,113 @@
 'use strict';
-
+const autoBind = require('auto-bind');
 const SchemaEndpointResolver = require('./utils/schemaEndpointResolver');
-
 const InputValidationError = require('./inputValidationError'),
     apiSchemaBuilder = require('api-schema-builder');
 const allowedFrameworks = ['express', 'koa', 'fastify'];
 
-let schemas = {};
-let middlewareOptions;
-let framework;
-let schemaEndpointResolver;
-let validationMiddleware;
-
-function init(swaggerPath, options) {
-    _baseInit(swaggerPath, options);
-    // build schema for requests only
-    const schemaBuilderOptions = Object.assign({}, options, { buildRequests: true, buildResponses: false });
-    schemas = apiSchemaBuilder.buildSchemaSync(swaggerPath, schemaBuilderOptions);
-}
+class Middleware {
+    constructor(swaggerPath, options) {
+        this.schemas = {};
+        this.middlewareOptions = undefined;
+        this.framework = undefined;
+        this.schemaEndpointResolver = undefined;
+        this.validationMiddleware = undefined;
+        this.InputValidationError = InputValidationError;
+        if (swaggerPath){
+            this.init(swaggerPath, options);
+        }
+        autoBind(this);
+    }
 
-async function initAsync(swaggerPath, options){
-    _baseInit(swaggerPath, options);
-    // build schema for requests only
-    const schemaBuilderOptions = Object.assign({}, options, { buildRequests: true, buildResponses: false });
-    schemas = await apiSchemaBuilder.buildSchema(swaggerPath, schemaBuilderOptions);
-}
+    async initAsync(swaggerPath, options) {
+        this._baseInit(options);
+        // build schema for requests only
+        const schemaBuilderOptions = Object.assign({}, options, { buildRequests: true, buildResponses: false });
+        this.schemas = await apiSchemaBuilder.buildSchema(swaggerPath, schemaBuilderOptions);
+    }
 
-function validate(...args) {
-    return validationMiddleware(...args);
-}
+    init (swaggerPath, options) {
+        this._baseInit(options);
+        // build schema for requests only
+        const schemaBuilderOptions = Object.assign({}, options, { buildRequests: true, buildResponses: false });
+        this.schemas = apiSchemaBuilder.buildSchemaSync(swaggerPath, schemaBuilderOptions);
+    }
 
-function _baseInit(swaggerPath, options) {
-    middlewareOptions = options || {};
-    const frameworkToLoad = allowedFrameworks.find((frameworkName) => {
-        return middlewareOptions.framework === frameworkName;
-    });
+    getNewMiddleware(swaggerPath, options) {
+        return new Middleware(swaggerPath, options);
+    }
 
-    framework = frameworkToLoad ? require(`./frameworks/${frameworkToLoad}`) : require('./frameworks/express');
-    validationMiddleware = framework.getValidator(_validateRequest);
-    schemaEndpointResolver = new SchemaEndpointResolver();
-}
+    validate(...args) {
+        return this.validationMiddleware(...args);
+    }
 
-function _getContentType(headers) {
-    // This is to filter out things like charset
-    const contentType = headers['content-type'];
-    return contentType && contentType.split(';')[0].trim();
-}
+    _baseInit (options) {
+        this.middlewareOptions = options || {};
+        const frameworkToLoad = allowedFrameworks.find((frameworkName) => {
+            return this.middlewareOptions.framework === frameworkName;
+        });
 
-function _validateRequest(requestOptions) {
-    const paramValidationErrors = _validateParams(requestOptions);
-    const bodyValidationErrors = _validateBody(requestOptions);
+        this.framework = frameworkToLoad ? require(`./frameworks/${frameworkToLoad}`) : require('./frameworks/express');
+        this.validationMiddleware = this.framework.getValidator((requestOptions) => this._validateRequest(requestOptions));
+        this.schemaEndpointResolver = new SchemaEndpointResolver();
+    }
 
-    const errors = paramValidationErrors.concat(bodyValidationErrors);
+    _getContentType (headers) {
+        // This is to filter out things like charset
+        const contentType = headers['content-type'];
+        return contentType && contentType.split(';')[0].trim();
+    }
 
-    if (errors.length) {
-        let error;
+    _validateRequest (requestOptions) {
+        const paramValidationErrors = this._validateParams(requestOptions);
+        const bodyValidationErrors = this._validateBody(requestOptions);
 
-        if (middlewareOptions.errorFormatter) {
-            error = middlewareOptions.errorFormatter(errors, middlewareOptions);
-        } else {
-            error = new InputValidationError(errors,
-                {
-                    beautifyErrors: middlewareOptions.beautifyErrors,
-                    firstError: middlewareOptions.firstError
-                });
-        }
+        const errors = paramValidationErrors.concat(bodyValidationErrors);
 
-        return error;
-    }
-}
+        if (errors.length) {
+            let error;
 
-function _validateBody(requestOptions) {
-    const { body, path } = requestOptions;
-    const method = requestOptions.method.toLowerCase();
-    const contentType = _getContentType(requestOptions.headers);
-    const methodSchema = schemaEndpointResolver.getMethodSchema(schemas, path, method) || {};
+            if (this.middlewareOptions.errorFormatter) {
+                error = this.middlewareOptions.errorFormatter(errors, this.middlewareOptions);
+            } else {
+                error = new InputValidationError(errors,
+                    {
+                        beautifyErrors: this.middlewareOptions.beautifyErrors,
+                        firstError: this.middlewareOptions.firstError
+                    });
+            }
 
-    if (methodSchema.body) {
-        const validator = methodSchema.body[contentType] || methodSchema.body;
-        if (!validator.validate(body)) {
-            return validator.errors || [];
+            return error;
         }
     }
 
-    return [];
-}
-
-function _validateParams(requestOptions) {
-    const { headers, params: pathParams, query, files, path } = requestOptions;
-    const method = requestOptions.method.toLowerCase();
+    _validateBody(requestOptions) {
+        const { body, path } = requestOptions;
+        const method = requestOptions.method.toLowerCase();
+        const contentType = this._getContentType(requestOptions.headers);
+        const methodSchema = this.schemaEndpointResolver.getMethodSchema(this.schemas, path, method) || {};
+
+        if (methodSchema.body) {
+            const validator = methodSchema.body[contentType] || methodSchema.body;
+            if (!validator.validate(body)) {
+                return validator.errors || [];
+            }
+        }
 
-    const methodSchema = schemaEndpointResolver.getMethodSchema(schemas, path, method);
-    if (methodSchema && methodSchema.parameters && !methodSchema.parameters.validate({ query: query, headers: headers, path: pathParams, files: files })) {
-        return methodSchema.parameters.errors || [];
+        return [];
     }
 
-    return [];
+    _validateParams (requestOptions) {
+        const { headers, params: pathParams, query, files, path } = requestOptions;
+        const method = requestOptions.method.toLowerCase();
+
+        const methodSchema = this.schemaEndpointResolver.getMethodSchema(this.schemas, path, method);
+        if (methodSchema && methodSchema.parameters && !methodSchema.parameters.validate({ query: query, headers: headers, path: pathParams, files: files })) {
+            return methodSchema.parameters.errors || [];
+        }
+
+        return [];
+    }
 }
 
-module.exports = {
-    init,
-    initAsync,
-    validate,
-    InputValidationError
-};
+module.exports = new Middleware();

src/middleware.js

@@ -3,8 +3,10 @@
 const chai = require('chai'),
     expect = chai.expect,
     chaiSinon = require('sinon-chai'),
-    request = require('supertest');
+    request = require('supertest'),
+    inputValidation = require('../../src/middleware');
 chai.use(chaiSinon);
+
 const inputValidationOptions = function () {
     return {
         formats: [
@@ -432,4 +434,45 @@ describe('input-validation middleware tests', function () {
             });
         });
     });
+    describe('support multi instances', function (){
+        before(function (){
+            app = require('./test-server-validator-instance')(inputValidationOptions());
+        });
+
+        describe('when running server with two seperated yaml one with get and other with post - should make validator per each yaml', function (){
+            it('verify two instances has two different schemas', function (){
+                const inputValidationWithGet = inputValidation.getNewMiddleware(`${__dirname}/pets-instance1.yaml`);
+                const inputValidationWithPost = inputValidation.getNewMiddleware(`${__dirname}/pets-instance2.yaml`);
+                expect(JSON.stringify(inputValidationWithGet.schemas)).eql('{"/pets":{"get":{}}}');
+                expect(JSON.stringify(inputValidationWithPost.schemas)).eql('{"/pets":{"post":{"body":{"errors":null,"application/json":{"errors":null},"application/x-www-form-urlencoded":{"errors":null}},"parameters":{"errors":null}}}}');
+            });
+            it('get pets from pets-instance1.yaml', function (done){
+                request(app)
+                    .get('/pets')
+                    .expect(200, function (err, res) {
+                        if (err) {
+                            throw err;
+                        }
+                        expect(res.body.result).to.equal('OK');
+                        done();
+                    });
+            });
+
+            it('post pets from pets-instance2.yaml', function (done){
+                request(app)
+                    .post('/pets')
+                    .set('public-key', '1.0')
+                    .send({
+                        bark: 'hav hav'
+                    })
+                    .expect(200, function (err, res) {
+                        if (err) {
+                            throw err;
+                        }
+                        expect(res.body.result).to.equal('OK');
+                        done();
+                    });
+            });
+        });
+    });
 });