Added tests for cache key parameters on additional endpoints

README.md

@@ -53,6 +53,10 @@ functions:
               - name: request.header.Accept-Language
 ```
 
+## Only supports REST API
+
+This plugin only supports REST API, because HTTP API does not support API Gateway Caching at the time of this writing. See [docs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html).
+
 ## Time-to-live, encryption, cache invalidation settings
 
 You can use the `apiGatewayCaching` section ("global settings") to quickly configure cache time-to-live, data encryption and per-key cache invalidation for all endpoints. The settings are inherited by each endpoint for which caching is enabled.
@@ -147,8 +151,8 @@ functions:
 
 When the endpoint is hit, API Gateway will create cache entries based on the `pawId` path parameter and the `catName` query string parameter. For instance:
 - `GET /cats/4` will create a cache entry for `pawId=4` and `catName` as `undefined`.
-- `GET /cats/34?catName=Toby` will create a cache entry for `pawId=34` and `catName=Toby`.
-- `GET /cats/72?catName=Dixon&furColour=white` will create a cache entry for `pawId=72` and `catName=Dixon`, but will ignore the `furColour` query string parameter. That means that a subsequent request to `GET /cats/72?catName=Dixon&furColour=black` will return the cached response for `pawId=72` and `catName=Dixon`.
+- `GET /cats/34?catName=Dixon` will create a cache entry for `pawId=34` and `catName=Dixon`.
+- `GET /cats/72?catName=Tsunami&furColour=white` will create a cache entry for `pawId=72` and `catName=Tsunami`, but will ignore the `furColour` query string parameter. That means that a subsequent request to `GET /cats/72?catName=Tsunami&furColour=black` will return the cached response for `pawId=72` and `catName=Tsunami`.
 
 ### Cache key parameters from the path, query string and header
 When an endpoint varies its responses based on values found in the `path`, `query string` or `header`, you can specify all the parameter names as cache key parameters:
@@ -387,6 +391,53 @@ custom:
           dataEncrypted: true # if not set, inherited from global settings
 ```
 
+## Configuring caching when the endpoint bypasses lambda and talks to a service like DynamoDb
+
+This example uses the `serverless-apigateway-service-proxy` plugin which creates the path `/dynamodb?id=cat_id`.
+Caching can be configured using the `additionalEndpoints` feature. The method and path must match the ones defined as a service proxy. It also supports cache key parameters.
+
+```yml
+plugins:
+  - serverless-api-gateway-caching
+  - serverless-apigateway-service-proxy
+
+custom:
+  apiGatewayCaching:
+    enabled: true
+    additionalEndpoints:
+      - method: GET
+        path: /dynamodb
+        caching:
+          enabled: true
+          ttlInSeconds: 120
+          cacheKeyParameters:
+            - name: request.querystring.id
+
+  apiGatewayServiceProxies:
+    - dynamodb:
+        path: /dynamodb
+        method: get
+        tableName: { Ref: 'MyDynamoCatsTable' }
+        hashKey:
+          queryStringParam: id # use query string parameter
+          attributeType: S
+        action: GetItem
+        cors: true
+
+resources:
+  Resources:
+    MyDynamoCatsTable:
+      Type: AWS::DynamoDB::Table
+      Properties:
+        TableName: my-dynamo-cats
+        AttributeDefinitions:
+          - AttributeName: id
+            AttributeType: S
+        KeySchema:
+          - AttributeName: id
+            KeyType: HASH
+```
+
 ## More Examples
 
 A function with several endpoints:

src/apiGatewayCachingPlugin.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const ApiGatewayCachingSettings = require('./ApiGatewayCachingSettings');
-const pathParametersCache = require('./pathParametersCache');
+const cacheKeyParameters = require('./cacheKeyParameters');
 const updateStageCacheSettings = require('./stageCache');
 const { restApiExists, outputRestApiIdTo } = require('./restApiId');
 
@@ -37,7 +37,7 @@ class ApiGatewayCachingPlugin {
       return;
     }
 
-    return pathParametersCache.addPathParametersCacheConfig(this.settings, this.serverless);
+    return cacheKeyParameters.addCacheKeyParametersConfig(this.settings, this.serverless);
   }
 
   async updateStage() {

src/pathParametersCache.js → src/cacheKeyParameters.js

@@ -7,7 +7,7 @@ const getResourcesByName = (name, serverless) => {
   }
 }
 
-const applyPathParameterCacheSettings = (settings, serverless) => {
+const applyCacheKeyParameterSettings = (settings, serverless) => {
   for (let endpointSettings of settings) {
     if (!endpointSettings.cacheKeyParameters) {
       continue;
@@ -58,11 +58,11 @@ const applyPathParameterCacheSettings = (settings, serverless) => {
     method.Properties.Integration.CacheNamespace = `${endpointSettings.gatewayResourceName}CacheNS`;
   }
 }
-const addPathParametersCacheConfig = (settings, serverless) => {
-  applyPathParameterCacheSettings(settings.endpointSettings, serverless);
-  applyPathParameterCacheSettings(settings.additionalEndpointSettings, serverless);
+const addCacheKeyParametersConfig = (settings, serverless) => {
+  applyCacheKeyParameterSettings(settings.endpointSettings, serverless);
+  applyCacheKeyParameterSettings(settings.additionalEndpointSettings, serverless);
 }
 
 module.exports = {
-  addPathParametersCacheConfig: addPathParametersCacheConfig
+  addCacheKeyParametersConfig: addCacheKeyParametersConfig
 }

test/configuring-cache-key-parameters-for-additional-endpoints.js

@@ -0,0 +1,87 @@
+const given = require('../test/steps/given');
+const ApiGatewayCachingSettings = require('../src/ApiGatewayCachingSettings');
+const cacheKeyParams = require('../src/cacheKeyParameters');
+const expect = require('chai').expect;
+
+describe('Configuring path parameters for additional endpoints defined as CloudFormation', () => {
+    let serverless;
+    let serviceName = 'cat-api', stage = 'dev';
+
+    describe('when there are no additional endpoints', () => {
+        before(() => {
+            serverless = given.a_serverless_instance(serviceName)
+                .withApiGatewayCachingConfig()
+                .forStage(stage);
+        });
+
+        it('should do nothing to the serverless instance', () => {
+            let stringified = JSON.stringify(serverless);
+            when_configuring_cache_key_parameters(serverless);
+            let stringifiedAfter = JSON.stringify(serverless);
+            expect(stringified).to.equal(stringifiedAfter);
+        });
+    });
+
+    describe('when one of the additional endpoints has cache key parameters', () => {
+        let cacheKeyParameters, apiGatewayMethod;
+        before(() => {
+            cacheKeyParameters = [
+                { name: 'request.path.pawId' },
+                { name: 'request.header.Accept-Language' }]
+            const additionalEndpointWithCaching = given.an_additional_endpoint({
+                method: 'GET', path: '/items',
+                caching: {
+                    enabled: true, ttlInSeconds: 120,
+                    cacheKeyParameters
+                }
+            })
+            const additionalEndpointWithoutCaching = given.an_additional_endpoint({
+                method: 'POST', path: '/blue-items',
+                caching: { enabled: true }
+            });
+
+            serverless = given.a_serverless_instance(serviceName)
+                .withApiGatewayCachingConfig()
+                .withAdditionalEndpoints([additionalEndpointWithCaching, additionalEndpointWithoutCaching])
+                .forStage('somestage');
+
+            when_configuring_cache_key_parameters(serverless);
+
+            apiGatewayMethod = serverless.getMethodResourceForAdditionalEndpoint(additionalEndpointWithCaching);
+        });
+
+        it('should configure the method\'s request parameters', () => {
+            for (let parameter of cacheKeyParameters) {
+                expect(apiGatewayMethod.Properties.RequestParameters)
+                    .to.deep.include({
+                        [`method.${parameter.name}`]: {}
+                    });
+            }
+        });
+
+        it('should not set integration request parameters', () => {
+            for (let parameter of cacheKeyParameters) {
+                expect(apiGatewayMethod.Properties.Integration.RequestParameters)
+                    .to.not.include({
+                        [`integration.${parameter.name}`]: `method.${parameter.name}`
+                    });
+            }
+        });
+
+        it('should set the method\'s integration cache key parameters', () => {
+            for (let parameter of cacheKeyParameters) {
+                expect(apiGatewayMethod.Properties.Integration.CacheKeyParameters)
+                    .to.include(`method.${parameter.name}`);
+            }
+        });
+
+        it('should set a cache namespace', () => {
+            expect(apiGatewayMethod.Properties.Integration.CacheNamespace).to.exist;
+        });
+    });
+});
+
+const when_configuring_cache_key_parameters = (serverless) => {
+    let cacheSettings = new ApiGatewayCachingSettings(serverless);
+    return cacheKeyParams.addCacheKeyParametersConfig(cacheSettings, serverless);
+}

test/configuring-path-parameters.js → test/configuring-cache-key-parameters.js

@@ -1,10 +1,10 @@
 const APP_ROOT = '..';
 const given = require(`${APP_ROOT}/test/steps/given`);
 const ApiGatewayCachingSettings = require(`${APP_ROOT}/src/ApiGatewayCachingSettings`);
-const pathParams = require(`${APP_ROOT}/src/pathParametersCache`);
+const cacheKeyParams = require(`${APP_ROOT}/src/cacheKeyParameters`);
 const expect = require('chai').expect;
 
-describe('Configuring path parameter caching', () => {
+describe('Configuring cache key parameters', () => {
   let serverless;
   let serviceName = 'cat-api', stage = 'dev';
 
@@ -17,7 +17,7 @@ describe('Configuring path parameter caching', () => {
 
     it('should do nothing to the serverless instance', () => {
       let stringified = JSON.stringify(serverless);
-      when_configuring_path_parameters(serverless);
+      when_configuring_cache_key_parameters(serverless);
       let stringifiedAfter = JSON.stringify(serverless);
       expect(stringified).to.equal(stringifiedAfter);
     });
@@ -35,7 +35,7 @@ describe('Configuring path parameter caching', () => {
 
     it('should do nothing to the serverless instance', () => {
       let stringified = JSON.stringify(serverless);
-      when_configuring_path_parameters(serverless);
+      when_configuring_cache_key_parameters(serverless);
       let stringifiedAfter = JSON.stringify(serverless);
       expect(stringified).to.equal(stringifiedAfter);
     });
@@ -56,7 +56,7 @@ describe('Configuring path parameter caching', () => {
         .forStage(stage)
         .withFunction(functionWithCaching);
 
-      when_configuring_path_parameters(serverless);
+      when_configuring_cache_key_parameters(serverless);
 
       method = serverless.getMethodResourceForFunction(functionWithCachingName);
     });
@@ -110,7 +110,7 @@ describe('Configuring path parameter caching', () => {
         .withFunction(functionWithCaching)
         .withFunction(functionWithoutCaching);
 
-      when_configuring_path_parameters(serverless);
+      when_configuring_cache_key_parameters(serverless);
     });
 
 
@@ -191,7 +191,7 @@ describe('Configuring path parameter caching', () => {
         .withFunction(functionWithCaching)
         .withFunction(functionWithoutCaching);
 
-      when_configuring_path_parameters(serverless);
+      when_configuring_cache_key_parameters(serverless);
     });
 
     describe('on the method corresponding with the endpoint with cache key parameters', () => {
@@ -262,7 +262,7 @@ describe('Configuring path parameter caching', () => {
           method = serverless.getMethodResourceForFunction(functionWithCachingName);
           method.Properties.RequestParameters[`method.${cacheKeyParameters[0].name}`] = isRequired;
 
-          when_configuring_path_parameters(serverless)
+          when_configuring_cache_key_parameters(serverless)
         });
 
         it('should keep configuration', () => {
@@ -296,7 +296,7 @@ describe('Configuring path parameter caching', () => {
           .withFunction(firstFunctionWithCaching)
           .withFunction(secondFunctionWithCaching);
 
-        when_configuring_path_parameters(serverless);
+        when_configuring_cache_key_parameters(serverless);
       });
 
       describe('on the method corresponding with the first endpoint with cache key parameters', () => {
@@ -387,7 +387,7 @@ describe('Configuring path parameter caching', () => {
         .forStage(stage)
         .withFunction(firstFunctionWithCaching)
 
-      when_configuring_path_parameters(serverless);
+      when_configuring_cache_key_parameters(serverless);
     });
 
     describe('on the method corresponding with the first endpoint with cache key parameters', () => {
@@ -494,7 +494,7 @@ describe('Configuring path parameter caching', () => {
           .forStage(stage)
           .withFunction(functionWithCaching);
 
-        when_configuring_path_parameters(serverless)
+        when_configuring_cache_key_parameters(serverless)
       });
 
       describe('on the corresponding method', () => {
@@ -551,7 +551,7 @@ describe('Configuring path parameter caching', () => {
         .forStage(stage)
         .withFunction(functionWithCaching);
 
-      when_configuring_path_parameters(serverless)
+      when_configuring_cache_key_parameters(serverless)
     });
 
     describe('on the GET method', () => {
@@ -638,7 +638,7 @@ describe('Configuring path parameter caching', () => {
   });
 });
 
-const when_configuring_path_parameters = (serverless) => {
+const when_configuring_cache_key_parameters = (serverless) => {
   let cacheSettings = new ApiGatewayCachingSettings(serverless);
-  return pathParams.addPathParametersCacheConfig(cacheSettings, serverless);
+  return cacheKeyParams.addCacheKeyParametersConfig(cacheSettings, serverless);
 }

test/creating-plugin.js

@@ -12,38 +12,38 @@ describe('Creating plugin', () => {
         thereIsARestApi: false,
         expectedLogMessage: '[serverless-api-gateway-caching] No REST API found. Caching settings will not be updated.',
         expectedToOutputRestApiId: false,
-        expectedToAddPathParametersCacheConfig: false
+        expectedToAddCacheKeyParametersConfig: false
       },
       {
         description: 'there is a REST API and caching is enabled',
         cachingEnabled: true,
         thereIsARestApi: true,
         expectedLogMessage: undefined,
         expectedToOutputRestApiId: true,
-        expectedToAddPathParametersCacheConfig: true,
+        expectedToAddCacheKeyParametersConfig: true,
       },
       {
         description: 'there is a REST API and caching is disabled',
         cachingEnabled: false,
         thereIsARestApi: true,
         expectedLogMessage: undefined,
         expectedToOutputRestApiId: true,
-        expectedToAddPathParametersCacheConfig: false,
+        expectedToAddCacheKeyParametersConfig: false,
       }
     ];
 
     for (let scenario of scenarios) {
       describe(`and ${scenario.description}`, () => {
-        let logCalledWith, outputRestApiIdCalled = false, addPathParametersCacheConfigCalled = false;
+        let logCalledWith, outputRestApiIdCalled = false, addCacheKeyParametersConfigCalled = false;
         const serverless = { cli: { log: (message) => { logCalledWith = message } } };
         const restApiIdStub = {
           restApiExists: () => scenario.thereIsARestApi,
           outputRestApiIdTo: () => outputRestApiIdCalled = true
         };
-        const pathParametersCacheStub = {
-          addPathParametersCacheConfig: () => addPathParametersCacheConfigCalled = true
+        const cacheKeyParametersStub = {
+          addCacheKeyParametersConfig: () => addCacheKeyParametersConfigCalled = true
         }
-        const ApiGatewayCachingPlugin = proxyquire('../src/apiGatewayCachingPlugin', { './restApiId': restApiIdStub, './pathParametersCache': pathParametersCacheStub });
+        const ApiGatewayCachingPlugin = proxyquire('../src/apiGatewayCachingPlugin', { './restApiId': restApiIdStub, './cacheKeyParameters': cacheKeyParametersStub });
 
         before(() => {
           const plugin = new ApiGatewayCachingPlugin(serverless, {});
@@ -59,8 +59,8 @@ describe('Creating plugin', () => {
           expect(outputRestApiIdCalled).to.equal(scenario.expectedToOutputRestApiId);
         });
 
-        it(`is expected to add path parameters to cache config: ${scenario.expectedToAddPathParametersCacheConfig}`, () => {
-          expect(addPathParametersCacheConfigCalled).to.equal(scenario.expectedToAddPathParametersCacheConfig);
+        it(`is expected to add path parameters to cache config: ${scenario.expectedToAddCacheKeyParametersConfig}`, () => {
+          expect(addCacheKeyParametersConfigCalled).to.equal(scenario.expectedToAddCacheKeyParametersConfig);
         });
       });
     }