Match path to endpoint regardless of id name (#74)

kibertoad · kobik · commit afbb7834b3f5 · 2019-06-30T08:30:56.000+03:00
* Match path to endpoint regardless of id name

* Add memoization to improve performance

* Address code review comment
diff --git a/package.json b/package.json
@@ -56,7 +56,8 @@
   "author": "Idan Tovi",
   "license": "Apache-2.0",
   "dependencies": {
-    "api-schema-builder": "^1.0.9"
+    "api-schema-builder": "^1.0.9",
+    "memoizee": "^0.4.14"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^1.9.0",
diff --git a/src/middleware.js b/src/middleware.js
@@ -1,12 +1,15 @@
 'use strict';
 
+const SchemaEndpointResolver = require('./utils/schemaEndpointResolver');
+
 const InputValidationError = require('./inputValidationError'),
     apiSchemaBuilder = require('api-schema-builder');
 const allowedFrameworks = ['express', 'koa'];
 
 let schemas = {};
 let middlewareOptions;
 let framework;
+let schemaEndpointResolver;
 
 function init(swaggerPath, options) {
     middlewareOptions = options || {};
@@ -15,9 +18,10 @@ function init(swaggerPath, options) {
     });
 
     framework = frameworkToLoad ? require(`./frameworks/${frameworkToLoad}`) : require('./frameworks/express');
+    schemaEndpointResolver = new SchemaEndpointResolver();
 
     // build schema for requests only
-    let schemaBuilderOptions = Object.assign({}, options, {buildRequests: true, buildResponses: false});
+    let schemaBuilderOptions = Object.assign({}, options, { buildRequests: true, buildResponses: false });
     return apiSchemaBuilder.buildSchema(swaggerPath, schemaBuilderOptions).then((receivedSchemas) => {
         schemas = receivedSchemas;
     });
@@ -52,17 +56,19 @@ function _validateRequest(requestOptions) {
 
 function _validateBody(body, path, method) {
     return new Promise(function (resolve, reject) {
-        if (schemas[path] && schemas[path][method] && schemas[path][method].body && !schemas[path][method].body.validate(body)) {
-            return reject(schemas[path][method].body.errors);
+        const methodSchema = schemaEndpointResolver.getMethodSchema(schemas, path, method);
+        if (methodSchema && methodSchema.body && !methodSchema.body.validate(body)) {
+            return reject(methodSchema.body.errors);
         }
         return resolve();
     });
 }
 
 function _validateParams(headers, pathParams, query, files, path, method) {
     return new Promise(function (resolve, reject) {
-        if (schemas[path] && schemas[path][method] && schemas[path][method].parameters && !schemas[path][method].parameters.validate({ query: query, headers: headers, path: pathParams, files: files })) {
-            return reject(schemas[path][method].parameters.errors);
+        const methodSchema = schemaEndpointResolver.getMethodSchema(schemas, path, method);
+        if (methodSchema && methodSchema.parameters && !methodSchema.parameters.validate({ query: query, headers: headers, path: pathParams, files: files })) {
+            return reject(methodSchema.parameters.errors);
         }
 
         return resolve();
diff --git a/src/utils/schemaEndpointResolver.js b/src/utils/schemaEndpointResolver.js
@@ -0,0 +1,40 @@
+const memoize = require('memoizee');
+
+// This logic is wrapped into class to have isolated memoization contexts
+class SchemaEndpointResolver {
+    constructor() {
+        this.getMethodSchema = memoize(getMethodSchemaInternal);
+    }
+}
+
+function getMethodSchemaInternal(schemas, path, method) {
+    const methodLowerCase = method.toLowerCase();
+    const routePath = pathMatcher(schemas, path);
+    const route = schemas[routePath];
+
+    if (route && route[methodLowerCase]) {
+        return route[methodLowerCase];
+    }
+}
+
+function pathMatcher(routes, path) {
+    return Object
+        .keys(routes)
+        .find((route) => {
+            const routeArr = route.split('/');
+            const pathArr = path.split('/');
+
+            if (routeArr.length !== pathArr.length) return false;
+
+            return routeArr.every((seg, idx) => {
+                if (seg === pathArr[idx]) return true;
+
+                // if current path segment is param
+                if (seg.startsWith(':') && pathArr[idx]) return true;
+
+                return false;
+            });
+        });
+}
+
+module.exports = SchemaEndpointResolver;
diff --git a/test/openapi3/pets-parametrized.yaml b/test/openapi3/pets-parametrized.yaml
@@ -0,0 +1,228 @@
+openapi: 3.0.0
+servers:
+  - url: 'https://api.paymentsos.com/'
+info:
+  x-logo:
+    url: payos_logo_blue_pad.png
+    backgroundColor: white
+  description: >
+    # Overview
+
+  version: 1.2.0
+  title: PaymentsOS API
+tags:
+  - name: Tokens
+    description: >-
+      Tokenization is a process that safeguards sensitive card data, converting
+      a card's details to a representative token.
+x-tagGroups:
+  - name: Reference
+    tags:
+      - Tokens
+security:
+  - app-id: []
+    private-key: []
+paths:
+  /pets/{petId}:
+    get:
+      summary: get pet
+      security:
+      - public-key: []
+      description: >-
+      tags:
+      - pets
+      parameters:
+        - name: petId
+          in: path
+          required: true
+          description: The id of the pet to retrieve
+          schema:
+            type: string
+      operationId: getPet
+      responses:
+        '200':
+          description: pet
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/pet'
+        '400':
+          description: Bad request
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/error_model'
+        '401':
+          description: Unauthorize
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/error_model'
+        '500':
+          description: Internal error
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/error_model'
+    put:
+      summary: update pet
+      security:
+        - public-key: []
+      description: >-
+      tags:
+        - pets
+
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/pet'
+      parameters:
+        - name: petId
+          in: path
+          required: true
+          description: The id of the pet to retrieve
+          schema:
+            type: string
+      operationId: updatePet
+      responses:
+        '200':
+          description: pet
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/pet'
+        '400':
+          description: Bad request
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/error_model'
+        '401':
+          description: Unauthorize
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/error_model'
+        '500':
+          description: Internal error
+          headers:
+            x-zooz-request-id:
+              description: request id
+              schema:
+                type: string
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/error_model'
+components:
+  parameters:
+    public-key:
+      name: public-key
+      in: header
+      required: true
+      example: f8948bac-8f29-4a82-8cef-704fb1e6b7ca
+      schema:
+        type: string
+  schemas:
+    error_model:
+      required:
+        - description
+        - category
+      properties:
+        category:
+          type: string
+          description: Error code.
+        description:
+          type: string
+          description: Error message for the developer.
+        more_info:
+          type: string
+          description: 'More info about the error, can include link to the documentation.'
+    pet:
+      description: pet
+      type: object
+      oneOf:
+        - $ref: '#/components/schemas/dog_object'
+        - $ref: '#/components/schemas/cat_object'
+    pets:
+      type: array
+      items:
+        $ref: "#/components/schemas/pet"
+    dog_object:
+      type: object
+      required:
+        - bark
+      properties:
+        bark:
+          type: string
+    dog_multiple:
+      type: object
+      required:
+        - dog_age
+      discriminator:
+        propertyName: model
+      oneOf:
+        - $ref: '#/components/schemas/small_dog'
+        - $ref: '#/components/schemas/big_dog'
+      properties:
+        dog_age:
+          type: string
+    cat_object:
+      type: object
+      required:
+        - fur
+      properties:
+        fur:
+          type: string
+          pattern: '^\d+$'
+
+    small_dog:
+      type: object
+      required:
+        - max_length
+      properties:
+        max_length:
+          type: string
+    big_dog:
+      type: object
+      required:
+        - min_length
+      properties:
+        min_length:
+          type: string
diff --git a/test/utils/schemaEndpointResolver-test.js b/test/utils/schemaEndpointResolver-test.js
@@ -0,0 +1,45 @@
+const chai = require('chai'),
+    expect = chai.expect;
+const apiSchemaBuilder = require('api-schema-builder');
+const SchemaEndpointResolver = require('../../src/utils/schemaEndpointResolver');
+const swaggerPath = 'test/openapi3/pets-parametrized.yaml';
+
+describe('schemaEndpointResolver', () => {
+    let schemas;
+    let schemaEndpointResolver;
+    before(() => {
+        let schemaBuilderOptions = {buildRequests: true, buildResponses: true};
+        return apiSchemaBuilder.buildSchema(swaggerPath, schemaBuilderOptions).then((receivedSchemas) => {
+            schemas = receivedSchemas;
+        });
+    });
+    beforeEach(() => {
+        schemaEndpointResolver = new SchemaEndpointResolver();
+    });
+
+    it('resolves exact path correctly', () => {
+        const endpoint = schemaEndpointResolver.getMethodSchema(schemas, '/pets/:petId', 'get');
+        expect(endpoint).to.be.ok;
+    });
+
+    it('resolves using non-case-sensitive method', () => {
+        const endpoint = schemaEndpointResolver.getMethodSchema(schemas, '/pets/:petId', 'GET');
+        expect(endpoint).to.be.ok;
+    });
+
+    it('resolves ignoring path parameter name', () => {
+        const endpoint = schemaEndpointResolver.getMethodSchema(schemas, '/pets/:id', 'GET');
+        expect(endpoint).to.be.ok;
+    });
+
+    it('uses all three params to memoize result', () => {
+        const endpointGet = schemaEndpointResolver.getMethodSchema(schemas, '/pets/:id', 'GET');
+        expect(endpointGet.body).to.be.undefined;
+
+        const endpointPut = schemaEndpointResolver.getMethodSchema(schemas, '/pets/:id', 'PUT');
+        expect(endpointPut.body).to.be.ok;
+
+        const endpointGet2 = schemaEndpointResolver.getMethodSchema(schemas, '/pets/:id', 'GET');
+        expect(endpointGet2.body).to.be.undefined;
+    });
+});
