Merge pull request #33 from spring-media/open-api-parameters

added support for open api path parameters

Author: jpavek

README.md

@@ -52,6 +52,15 @@ export const handler = router.handler({
                 action: (request, context) => {
                     return "You called me with: " + request.paths.id;
                 }
+            },
+            {
+                // request-path-pattern with a path variable in Open API style:
+                path: '/section/{id}',
+                method: 'GET',
+                // we can use the path param 'id' in the action call:
+                action: (request, context) => {
+                    return "You called me with: " + request.paths.id;
+                }
             }
         ]
     }
@@ -77,7 +86,7 @@ const router = require('aws-lambda-router');
 
 exports.handler = router.handler({
     proxyIntegration: {
-        proxyPath: proxy
+        proxyPath: proxy,
         routes: [
             {
                 path: '/article/list',
@@ -348,7 +357,7 @@ return {
         body: JSON.stringify({
             foo: 'bar'
         })
-    };
+    }
 ```
 
 ## Local developement
@@ -359,6 +368,8 @@ See here: https://yarnpkg.com/en/docs/cli/link
 
 
 ## Release History
+* 0.8.2
+   * added support for Open API parameter definitions e.g.: /section/{id}
 * 0.8.1
    * fix: changed ProxyIntegrationEvent body type to be generic but defaults to unknown
    * fix: changed @types/aws-lambda from devDependency to dependency

lib/proxyIntegration.ts

@@ -233,13 +233,13 @@ const findMatchingActionConfig = (httpMethod: string, httpPath: string, routeCon
 }
 
 const extractPathValues = (pathExpression: string, httpPath: string) => {
-  const pathValueRegex = new RegExp('^' + pathExpression.replace(/:[\w]+/g, '([^/]+)') + '$')
+  const pathValueRegex = new RegExp('^' + pathExpression.replace(/{[\w]+}|:[\w]+/g, '([^/]+)') + '$')
   const pathValues = pathValueRegex.exec(httpPath)
   return pathValues && pathValues.length > 0 ? pathValues.slice(1) : null
 }
 
 const extractPathNames = (pathExpression: string) => {
-  const pathNameRegex = new RegExp('^' + pathExpression.replace(/:[\w.]+/g, ':([\\w]+)') + '$')
+  const pathNameRegex = new RegExp('^' + pathExpression.replace(/{[\w.]+}|:[\w.]+/g, '[:{]([\\w]+)}?') + '$')
   const pathNames = pathNameRegex.exec(pathExpression)
   return pathNames && pathNames.length > 0 ? pathNames.slice(1) : null
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-lambda-router",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "AWS lambda router",
   "main": "index.js",
   "types": "index.d.ts",

test/proxyIntegration.test.ts

@@ -47,35 +47,44 @@ describe('proxyIntegration.routeHandler.selection', () => {
     }, { httpMethod: 'GET', path: '/123' } as APIGatewayProxyEvent, context)
     expect(actionSpy).toHaveBeenCalledWith({ httpMethod: 'GET', path: '/123', paths: {} }, context)
   })
-  it('should select parameter match', () => {
+  forEach([
+    ['/:param'],
+    ['/{param}']
+  ]).it('should select parameter match', (path) => {
     const actionSpy = jasmine.createSpy('action')
     proxyIntegration({
       routes: [
         { path: '/', method: 'GET', action: () => '/' as any },
         { path: '/123', method: 'GET', action: () => '123' as any },
-        { path: '/:param', method: 'GET', action: actionSpy }
+        { path: path, method: 'GET', action: actionSpy }
       ]
     }, { httpMethod: 'GET', path: '/456' } as APIGatewayProxyEvent, context)
     expect(actionSpy).toHaveBeenCalledWith({ httpMethod: 'GET', path: '/456', paths: { param: '456' } }, context)
   })
-  it('should select static match', () => {
+  forEach([
+    ['/:param'],
+    ['/{param}']
+  ]).it('should select static match', (path) => {
     const actionSpy = jasmine.createSpy('action')
     proxyIntegration({
       routes: [
         { path: '/', method: 'GET', action: () => '/' as any },
         { path: '/123', method: 'GET', action: actionSpy },
-        { path: '/:param', method: 'GET', action: () => 'param' as any }
+        { path: path, method: 'GET', action: () => 'param' as any }
       ]
     }, { httpMethod: 'GET', path: '/123' } as APIGatewayProxyEvent, context)
     expect(actionSpy).toHaveBeenCalledWith({ httpMethod: 'GET', path: '/123', paths: {} }, context)
   })
-  it('should match urlencoded path', () => {
+  forEach([
+    ['/:param'],
+    ['/{param}']
+  ]).it('should match urlencoded path', (path) => {
     const actionSpy = jasmine.createSpy('action')
     proxyIntegration({
       routes: [
         { path: '/', method: 'GET', action: () => '/' as any },
         { path: '/123', method: 'GET', action: () => '123' as any },
-        { path: '/:param', method: 'GET', action: actionSpy }
+        { path: path, method: 'GET', action: actionSpy }
       ]
     }, { httpMethod: 'GET', path: '/%2Fwirtschaft%2Farticle85883...tml' } as APIGatewayProxyEvent, context)
     expect(actionSpy).toHaveBeenCalledWith({
@@ -84,11 +93,14 @@ describe('proxyIntegration.routeHandler.selection', () => {
       paths: { param: '/wirtschaft/article85883...tml' }
     }, context)
   })
-  it('should select match containing hyphen', () => {
+  forEach([
+    ['/:param'],
+    ['/{param}']
+  ]).it('should select match containing hyphen', (path) => {
     const actionSpy = jasmine.createSpy('action')
     proxyIntegration({
       routes: [
-        { path: '/:param', method: 'GET', action: actionSpy }
+        { path: path, method: 'GET', action: actionSpy }
       ]
     }, { httpMethod: 'GET', path: '/%2Fdeutschland-bewegt-sich%2F' } as APIGatewayProxyEvent, context)
     expect(actionSpy).toHaveBeenCalledWith({
@@ -97,11 +109,14 @@ describe('proxyIntegration.routeHandler.selection', () => {
       paths: { param: '/deutschland-bewegt-sich/' }
     }, context)
   })
-  it('should select match containing question marks and dots', () => {
+  forEach([
+    ['/:param'],
+    ['/{param}']
+  ]).it('should select match containing question marks and dots', (path) => {
     const actionSpy = jasmine.createSpy('action')
     proxyIntegration({
       routes: [
-        { path: '/:param', method: 'GET', action: actionSpy }
+        { path: path, method: 'GET', action: actionSpy }
       ]
     }, {
       httpMethod: 'GET',
@@ -264,7 +279,14 @@ describe('proxyIntegration.routeHandler', () => {
     ['/abc/:param1', '/abc/p1', { param1: 'p1' }],
     ['/abc/def/:param1', '/abc/def/p1', { param1: 'p1' }],
     ['/:param1/abc/:param2', '/p1/abc/p2', { param1: 'p1', param2: 'p2' }],
-    ['/:param1/abc/def/:param2', '/p1/abc/def/p2', { param1: 'p1', param2: 'p2' }]
+    ['/:param1/abc/def/:param2', '/p1/abc/def/p2', { param1: 'p1', param2: 'p2' }],
+    ['/{param1}', '/p1', { param1: 'p1' }],
+    ['/abc/{param1}', '/abc/p1', { param1: 'p1' }],
+    ['/abc/def/{param1}', '/abc/def/p1', { param1: 'p1' }],
+    ['/{param1}/abc/{param2}', '/p1/abc/p2', { param1: 'p1', param2: 'p2' }],
+    ['/{param1}/abc/def/{param2}', '/p1/abc/def/p2', { param1: 'p1', param2: 'p2' }],
+    ['/:param1/abc/{param2}', '/p1/abc/p2', { param1: 'p1', param2: 'p2' }],
+    ['/{param1}/abc/def/:param2', '/p1/abc/def/p2', { param1: 'p1', param2: 'p2' }]
   ]).it('should call action with path params for method/path', async (pathConfig, path, expectedPathValues) => {
     const spiedAction = jasmine.createSpy('action').and.returnValue({ foo: 'bar' })
     const routeConfig: ProxyIntegrationConfig = {