Merge branch 'release/1.2.1'

Author: diana.ionita

README.md

@@ -18,10 +18,9 @@ You can configure how to handle unauthorized requests to invalidate a cache key
 * `IgnoreWithWarning` - ignores the request to invalidate and adds a `warning` header in the response.
 * `Fail` - fails the request to invalidate the cache key with a 403 response status code.
 
-## Currently not supported:
-* lambda functions with many HTTP events.
+## Examples
 
-## Example
+### Minimal setup
 
 ```yml
 plugins:
@@ -31,24 +30,71 @@ custom:
   # Enable or disable caching globally
   apiGatewayCaching:
     enabled: true
-    clusterSize: '0.5' # defaults to '0.5'
-    ttlInSeconds: 300 # defaults to the maximum allowed: 3600
-    perKeyInvalidation:
-      requireAuthorization: true # default is true
-      handleUnauthorizedRequests: IgnoreWithWarning # default is "IgnoreWithWarning"
 
 functions:
-  # Responses are not cached
+  # Responses are cached
   list-all-cats:
     handler: rest_api/cats/get/handler.handle
-    role: listCatsRole
     events:
       - http:
           path: /cats
           method: get
           caching:
-            enabled: false # default is false
+            enabled: true
 
+  # Responses are *not* cached
+  update-cat:
+    handler: rest_api/cat/post/handler.handle
+    events:
+      - http:
+          path: /cat
+          method: post
+
+  # Responses are cached based on the 'pawId' path parameter and the 'Accept-Language' header
+  get-cat-by-paw-id:
+    handler: rest_api/cat/get/handler.handle
+    events:
+      - http:
+          path: /cats/{pawId}
+          method: get
+          caching:
+            enabled: true
+            cacheKeyParameters:
+              - name: request.path.pawId
+              - name: request.header.Accept-Language
+```
+
+### Configuring the cache cluster size and cache time to live
+Cache time to live and invalidation settings are applied to all functions, unless specifically overridden.
+
+```yml
+plugins:
+  - serverless-api-gateway-caching
+
+custom:
+  # Enable or disable caching globally
+  apiGatewayCaching:
+    enabled: true
+    clusterSize: '0.5' # defaults to '0.5'
+    ttlInSeconds: 300 # defaults to the maximum allowed: 3600
+    perKeyInvalidation:
+      requireAuthorization: true # default is true
+      handleUnauthorizedRequests: Ignore # default is "IgnoreWithWarning"
+
+```
+
+### Configuring per-function cache time to live, cache invalidation strategy and cache key parameters
+
+```yml
+plugins:
+  - serverless-api-gateway-caching
+
+custom:
+  # Enable or disable caching globally
+  apiGatewayCaching:
+    enabled: true
+
+functions:
   # Responses are cached based on the 'pawId' path parameter and the 'Accept-Language' header
   get-cat-by-paw-id:
     handler: rest_api/cat/get/handler.handle
@@ -60,8 +106,8 @@ functions:
             enabled: true
             ttlInSeconds: 3600
             perKeyInvalidation:
-              requireAuthorization: true
-              handleUnauthorizedRequests: Ignore
+              requireAuthorization: true # default is true
+              handleUnauthorizedRequests: Fail # default is "IgnoreWithWarning"
             cacheKeyParameters:
               - name: request.path.pawId
               - name: request.header.Accept-Language

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-api-gateway-caching",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "A plugin for the serverless framework which helps with configuring caching for API Gateway endpoints.",
   "main": "src/apiGatewayCachingPlugin.js",
   "scripts": {

package.json

@@ -10,35 +10,36 @@ const getResourcesByName = (name, serverless) => {
 }
 
 const getApiGatewayMethodNameFor = (path, httpMethod) => {
-  const pathElements = split(path,'/');
+  const pathElements = split(path, '/');
   pathElements.push(httpMethod.toLowerCase());
   let gatewayResourceName = pathElements
-              .map (element =>  {
-                  element = element.toLowerCase();
-                  if(element.startsWith('{')) {
-                      element = element.substring(element.indexOf('{') + 1,element.indexOf('}')) + "Var";
-                  }
-                  //capitalize first letter
-                  return element.charAt(0).toUpperCase() + element.slice(1);
-              }).reduce((a, b) => a + b);
+    .map(element => {
+      element = element.toLowerCase();
+      element = element.replace('+', '');
+      if (element.startsWith('{')) {
+        element = element.substring(element.indexOf('{') + 1, element.indexOf('}')) + "Var";
+      }
+      //capitalize first letter
+      return element.charAt(0).toUpperCase() + element.slice(1);
+    }).reduce((a, b) => a + b);
 
-  gatewayResourceName  = "ApiGatewayMethod" + gatewayResourceName;    
-  return gatewayResourceName;            
+  gatewayResourceName = "ApiGatewayMethod" + gatewayResourceName;
+  return gatewayResourceName;
 }
 
 const addPathParametersCacheConfig = (settings, serverless) => {
   for (let endpointSettings of settings.endpointSettings) {
     if (!endpointSettings.cacheKeyParameters) {
       continue;
-    }  
+    }
     const resourceName = getApiGatewayMethodNameFor(endpointSettings.path, endpointSettings.method);
-    const method = getResourcesByName(resourceName,serverless);
-    if (!method)  {
+    const method = getResourcesByName(resourceName, serverless);
+    if (!method) {
       serverless.cli.log(`[serverless-api-gateway-caching] The method ${resourceName} couldn't be found in the
                            compiled CloudFormation template. Caching settings will not be updated for this endpoint.`);
       const index = settings.endpointSettings.indexOf(endpointSettings);
-      if(index != -1) {
-        settings.endpointSettings.splice(index,1);
+      if (index != -1) {
+        settings.endpointSettings.splice(index, 1);
       }
       return;
     }
@@ -59,7 +60,7 @@ const addPathParametersCacheConfig = (settings, serverless) => {
   }
 }
 
-module.exports =   {
+module.exports = {
   addPathParametersCacheConfig: addPathParametersCacheConfig,
   getApiGatewayMethodNameFor: getApiGatewayMethodNameFor
 }

src/pathParametersCache.js

@@ -5,20 +5,19 @@ const pathParams = require(`${APP_ROOT}/src/pathParametersCache`);
 const expect = require('chai').expect;
 
 describe('Configuring path parameter caching', () => {
-  let serverless, cacheSettings;
+  let serverless;
   let serviceName = 'cat-api', stage = 'dev';
 
   describe('when there are no endpoints', () => {
     before(() => {
       serverless = given.a_serverless_instance(serviceName)
         .withApiGatewayCachingConfig(true, '0.5', 45)
         .forStage(stage);
-      cacheSettings = new ApiGatewayCachingSettings(serverless);
     });
 
     it('should do nothing to the serverless instance', () => {
       let stringified = JSON.stringify(serverless);
-      when_configuring_path_parameters(cacheSettings, serverless);
+      when_configuring_path_parameters(serverless);
       let stringifiedAfter = JSON.stringify(serverless);
       expect(stringified).to.equal(stringifiedAfter);
     });
@@ -32,12 +31,11 @@ describe('Configuring path parameter caching', () => {
         .withApiGatewayCachingConfig(true, '0.5', 45)
         .forStage(stage)
         .withFunction(endpoint);
-      cacheSettings = new ApiGatewayCachingSettings(serverless);
     });
 
     it('should do nothing to the serverless instance', () => {
       let stringified = JSON.stringify(serverless);
-      when_configuring_path_parameters(cacheSettings, serverless);
+      when_configuring_path_parameters(serverless);
       let stringifiedAfter = JSON.stringify(serverless);
       expect(stringified).to.equal(stringifiedAfter);
     });
@@ -61,9 +59,8 @@ describe('Configuring path parameter caching', () => {
         .forStage(stage)
         .withFunction(functionWithCaching)
         .withFunction(functionWithoutCaching);
-      cacheSettings = new ApiGatewayCachingSettings(serverless);
 
-      when_configuring_path_parameters(cacheSettings, serverless);
+      when_configuring_path_parameters(serverless);
     });
 
     describe('on the method corresponding with the endpoint with cache key parameters', () => {
@@ -156,8 +153,7 @@ describe('Configuring path parameter caching', () => {
           method = serverless.getMethodResourceForFunction(functionWithCachingName);
           method.Properties.RequestParameters[`method.${cacheKeyParameters[0].name}`] = isRequired;
 
-          cacheSettings = new ApiGatewayCachingSettings(serverless);
-          when_configuring_path_parameters(cacheSettings, serverless)
+          when_configuring_path_parameters(serverless)
         });
 
         it('should keep configuration', () => {
@@ -191,9 +187,7 @@ describe('Configuring path parameter caching', () => {
           .withFunction(firstFunctionWithCaching)
           .withFunction(secondFunctionWithCaching);
 
-        cacheSettings = new ApiGatewayCachingSettings(serverless);
-
-        when_configuring_path_parameters(cacheSettings, serverless);
+        when_configuring_path_parameters(serverless);
       });
 
       describe('on the method corresponding with the first endpoint with cache key parameters', () => {
@@ -267,26 +261,25 @@ describe('Configuring path parameter caching', () => {
       });
     });
   });
+
   describe('when there are two endpoints with a cache key parameter on the same function', () => {
-      let method, functionName, firstEndpointCacheKeyParameters, secondEndpointCacheKeyParameters;
-      before(() => {
-        functionName = 'catpaw';
-        
-        firstEndpointCacheKeyParameters = [{ name: 'request.path.pawId' }];
-        secondEndpointCacheKeyParameters = [{ name: 'request.path.pawId' }];
+    let method, functionName, firstEndpointCacheKeyParameters, secondEndpointCacheKeyParameters;
+    before(() => {
+      functionName = 'catpaw';
 
-        let firstFunctionWithCaching = given.a_serverless_function(functionName)
-          .withHttpEndpoint('get', '/cat/paw/{pawId}', { enabled: true, cacheKeyParameters: firstEndpointCacheKeyParameters })
-          .withHttpEndpoint('delete', '/cat/paw/{pawId}', { enabled: true, cacheKeyParameters: secondEndpointCacheKeyParameters });
-        serverless = given.a_serverless_instance(serviceName)
-          .withApiGatewayCachingConfig(true, '0.5', 45)
-          .forStage(stage)
-          .withFunction(firstFunctionWithCaching)
-        
-        cacheSettings = new ApiGatewayCachingSettings(serverless);
+      firstEndpointCacheKeyParameters = [{ name: 'request.path.pawId' }];
+      secondEndpointCacheKeyParameters = [{ name: 'request.path.pawId' }];
 
-        when_configuring_path_parameters(cacheSettings, serverless);
-  });
+      let firstFunctionWithCaching = given.a_serverless_function(functionName)
+        .withHttpEndpoint('get', '/cat/paw/{pawId}', { enabled: true, cacheKeyParameters: firstEndpointCacheKeyParameters })
+        .withHttpEndpoint('delete', '/cat/paw/{pawId}', { enabled: true, cacheKeyParameters: secondEndpointCacheKeyParameters });
+      serverless = given.a_serverless_instance(serviceName)
+        .withApiGatewayCachingConfig(true, '0.5', 45)
+        .forStage(stage)
+        .withFunction(firstFunctionWithCaching)
+
+      when_configuring_path_parameters(serverless);
+    });
 
     describe('on the method corresponding with the first endpoint with cache key parameters', () => {
       before(() => {
@@ -324,7 +317,7 @@ describe('Configuring path parameter caching', () => {
     });
 
     describe('on the method corresponding with the second endpoint with cache key parameters', () => {
-       before(() => {
+      before(() => {
         method = serverless.getMethodResourceForMethodName("ApiGatewayMethodCatPawPawidVarDelete");
       });
 
@@ -349,7 +342,60 @@ describe('Configuring path parameter caching', () => {
       it('should set integration cache key parameters', () => {
         for (let parameter of secondEndpointCacheKeyParameters) {
           expect(method.Properties.Integration.CacheKeyParameters)
-             .to.include(`method.${parameter.name}`);
+            .to.include(`method.${parameter.name}`);
+        }
+      });
+
+      it('should set a cache namespace', () => {
+        expect(method.Properties.Integration.CacheNamespace).to.exist;
+      });
+    });
+  });
+
+  describe('when an http event path contains the \'+\' special character', () => {
+    let cacheKeyParameters, functionWithCachingName;
+    before(() => {
+      functionWithCachingName = 'get-cat-by-paw-id';
+      cacheKeyParameters = [{ name: 'request.path.pawId' }, { name: 'request.header.Accept-Language' }];
+
+      let functionWithCaching = given.a_serverless_function(functionWithCachingName)
+        .withHttpEndpoint('get', '/cat/{pawId+}', { enabled: true, cacheKeyParameters });
+
+      serverless = given.a_serverless_instance(serviceName)
+        .withApiGatewayCachingConfig(true, '0.5', 45)
+        .forStage(stage)
+        .withFunction(functionWithCaching);
+
+      when_configuring_path_parameters(serverless)
+    });
+
+    describe('on the corresponding method', () => {
+      before(() => {
+        method = serverless.getMethodResourceForFunction(functionWithCachingName);
+      });
+
+      it('should configure cache key parameters as request parameters', () => {
+        for (let parameter of cacheKeyParameters) {
+          expect(method.Properties.RequestParameters)
+            .to.deep.include({
+              [`method.${parameter.name}`]: {}
+            });
+        }
+      });
+
+      it('should set integration request parameters', () => {
+        for (let parameter of cacheKeyParameters) {
+          expect(method.Properties.Integration.RequestParameters)
+            .to.deep.include({
+              [`integration.${parameter.name}`]: `method.${parameter.name}`
+            });
+        }
+      });
+
+      it('should set integration cache key parameters', () => {
+        for (let parameter of cacheKeyParameters) {
+          expect(method.Properties.Integration.CacheKeyParameters)
+            .to.include(`method.${parameter.name}`);
         }
       });
 
@@ -360,6 +406,7 @@ describe('Configuring path parameter caching', () => {
   });
 });
 
-const when_configuring_path_parameters = (settings, serverless) => {
-  return pathParams.addPathParametersCacheConfig(settings, serverless);
+const when_configuring_path_parameters = (serverless) => {
+  let cacheSettings = new ApiGatewayCachingSettings(serverless);
+  return pathParams.addPathParametersCacheConfig(cacheSettings, serverless);
 }