Add support for multiple usage plans

docs/providers/aws/events/apigateway.md

@@ -543,6 +543,45 @@ Please note that those are the API keys names, not the actual values. Once you d
 
 Clients connecting to this Rest API will then need to set any of these API keys values in the `x-api-key` header of their request. This is only necessary for functions where the `private` property is set to true.
 
+You can also setup multiple usage plans for your API. In this case you need to map your usage plans to your api keys. Here's an example how this might look like:
+
+```yml
+service: my-service
+provider:
+  name: aws
+  apiKeys:
+    - free:
+      - myFreeKey
+      - ${opt:stage}-myFreeKey
+    - paid:
+      - myPaidKey
+      - ${opt:stage}-myPaidKey
+  usagePlan:
+    - free:
+        quota:
+          limit: 5000
+          offset: 2
+          period: MONTH
+        throttle:
+          burstLimit: 200
+          rateLimit: 100
+    - paid:
+        quota:
+          limit: 50000
+          offset: 1
+          period: MONTH
+        throttle:
+          burstLimit: 2000
+          rateLimit: 1000
+functions:
+  hello:
+    events:
+      - http:
+          path: user/create
+          method: get
+          private: true
+```
+
 ### Configuring endpoint types
 
 API Gateway [supports regional endpoints](https://aws.amazon.com/about-aws/whats-new/2017/11/amazon-api-gateway-supports-regional-api-endpoints/) for associating your API Gateway REST APIs with a particular region. This can reduce latency if your requests originate from the same region as your REST API and can be helpful in building multi-region applications.

docs/providers/aws/guide/resources.md

@@ -82,9 +82,9 @@ If you are unsure how a resource is named, that you want to reference from your
 |ApiGateway::Method     | ApiGatewayMethod{normalizedPath}{normalizedMethod}      | ApiGatewayMethodUsersGet      |
 |ApiGateway::Authorizer | {normalizedFunctionName}ApiGatewayAuthorizer            | HelloApiGatewayAuthorizer     |
 |ApiGateway::Deployment | ApiGatewayDeployment{instanceId}                      | ApiGatewayDeployment12356789  |
-|ApiGateway::ApiKey     | ApiGatewayApiKey{SequentialID}                          | ApiGatewayApiKey1             |
-|ApiGateway::UsagePlan  | ApiGatewayUsagePlan                          | ApiGatewayUsagePlan             |
-|ApiGateway::UsagePlanKey     | ApiGatewayUsagePlanKey{SequentialID}                          | ApiGatewayUsagePlanKey1             |
+|ApiGateway::ApiKey     | ApiGatewayApiKey{OptionalNormalizedName}{SequentialID}  | ApiGatewayApiKeyFree1       |
+|ApiGateway::UsagePlan  | ApiGatewayUsagePlan{OptionalNormalizedName}             | ApiGatewayUsagePlanFree             |
+|ApiGateway::UsagePlanKey | ApiGatewayUsagePlanKey{OptionalNormalizedName}{SequentialID} | ApiGatewayUsagePlanKeyFree1  |
 |ApiGateway::Stage     | ApiGatewayStage                          | ApiGatewayStage             |
 |SNS::Topic             | SNSTopic{normalizedTopicName}                           | SNSTopicSometopic             |
 |SNS::Subscription      | {normalizedFunctionName}SnsSubscription{normalizedTopicName}   | HelloSnsSubscriptionSomeTopic             |

lib/plugins/aws/info/getApiKeyValues.js

@@ -9,7 +9,20 @@ module.exports = {
     info.apiKeys = [];
 
     // check if the user has set api keys
-    const apiKeyNames = this.serverless.service.provider.apiKeys || [];
+    const apiKeyDefinitions = this.serverless.service.provider.apiKeys;
+    const apiKeyNames = [];
+    if (_.isArray(apiKeyDefinitions) && apiKeyDefinitions.length) {
+      _.forEach(apiKeyDefinitions, (definition) => {
+        // different API key types are nested in separate arrays
+        if (_.isObject(definition)) {
+          const keyTypeName = Object.keys(definition)[0];
+          _.forEach(definition[keyTypeName], (keyName) => apiKeyNames.push(keyName));
+        } else if (_.isString(definition)) {
+          // plain strings are simple, non-nested API keys
+          apiKeyNames.push(definition);
+        }
+      });
+    }
 
     if (apiKeyNames.length) {
       return this.provider.request('APIGateway',

lib/plugins/aws/info/getApiKeyValues.test.js

@@ -27,7 +27,7 @@ describe('#getApiKeyValues()', () => {
     awsInfo.provider.request.restore();
   });
 
-  it('should add API Key values to this.gatheredData if API key names are available', () => {
+  it('should add API Key values to this.gatheredData if simple API key names are available', () => {
     // set the API Keys for the service
     awsInfo.serverless.service.provider.apiKeys = ['foo', 'bar'];
 
@@ -78,6 +78,78 @@ describe('#getApiKeyValues()', () => {
     });
   });
 
+  it('should add API Key values to this.gatheredData if typed API key names are available', () => {
+    // set the API Keys for the service
+    awsInfo.serverless.service.provider.apiKeys = [
+      { free: ['foo', 'bar'] },
+      { paid: ['baz', 'qux'] },
+    ];
+
+    awsInfo.gatheredData = {
+      info: {},
+    };
+
+    const apiKeyItems = {
+      items: [
+        {
+          id: '4711',
+          name: 'SomeRandomIdInUsersAccount',
+          value: 'ShouldNotBeConsidered',
+        },
+        {
+          id: '1234',
+          name: 'foo',
+          value: 'valueForKeyFoo',
+        },
+        {
+          id: '5678',
+          name: 'bar',
+          value: 'valueForKeyBar',
+        },
+        {
+          id: '9101112',
+          name: 'baz',
+          value: 'valueForKeyBaz',
+        },
+        {
+          id: '13141516',
+          name: 'qux',
+          value: 'valueForKeyQux',
+        },
+      ],
+    };
+
+    requestStub.resolves(apiKeyItems);
+
+    const expectedGatheredDataObj = {
+      info: {
+        apiKeys: [
+          {
+            name: 'foo',
+            value: 'valueForKeyFoo',
+          },
+          {
+            name: 'bar',
+            value: 'valueForKeyBar',
+          },
+          {
+            name: 'baz',
+            value: 'valueForKeyBaz',
+          },
+          {
+            name: 'qux',
+            value: 'valueForKeyQux',
+          },
+        ],
+      },
+    };
+
+    return awsInfo.getApiKeyValues().then(() => {
+      expect(requestStub.calledOnce).to.equal(true);
+      expect(awsInfo.gatheredData).to.deep.equal(expectedGatheredDataObj);
+    });
+  });
+
   it('should resolve if AWS does not return API key values', () => {
     // set the API Keys for the service
     awsInfo.serverless.service.provider.apiKeys = ['foo', 'bar'];

lib/plugins/aws/lib/naming.js

@@ -242,16 +242,25 @@ module.exports = {
   getMethodLogicalId(resourceId, methodName) {
     return `ApiGatewayMethod${resourceId}${this.normalizeMethodName(methodName)}`;
   },
-  getApiKeyLogicalId(apiKeyNumber) {
+  getApiKeyLogicalId(apiKeyNumber, apiKeyName) {
+    if (apiKeyName) {
+      return `ApiGatewayApiKey${this.normalizeName(apiKeyName)}${apiKeyNumber}`;
+    }
     return `ApiGatewayApiKey${apiKeyNumber}`;
   },
   getApiKeyLogicalIdRegex() {
     return /^ApiGatewayApiKey/;
   },
-  getUsagePlanLogicalId() {
+  getUsagePlanLogicalId(name) {
+    if (name) {
+      return `ApiGatewayUsagePlan${this.normalizeName(name)}`;
+    }
     return 'ApiGatewayUsagePlan';
   },
-  getUsagePlanKeyLogicalId(usagePlanKeyNumber) {
+  getUsagePlanKeyLogicalId(usagePlanKeyNumber, usagePlanKeyName) {
+    if (usagePlanKeyName) {
+      return `ApiGatewayUsagePlanKey${this.normalizeName(usagePlanKeyName)}${usagePlanKeyNumber}`;
+    }
     return `ApiGatewayUsagePlanKey${usagePlanKeyNumber}`;
   },
   getStageLogicalId() {

lib/plugins/aws/lib/naming.test.js

@@ -394,6 +394,10 @@ describe('#naming()', () => {
     it('should produce the given index with ApiGatewayApiKey as a prefix', () => {
       expect(sdk.naming.getApiKeyLogicalId(1)).to.equal('ApiGatewayApiKey1');
     });
+
+    it('should support API Key names', () => {
+      expect(sdk.naming.getApiKeyLogicalId(1, 'free')).to.equal('ApiGatewayApiKeyFree1');
+    });
   });
 
   describe('#getApiKeyLogicalIdRegex()', () => {
@@ -414,16 +418,26 @@ describe('#naming()', () => {
   });
 
   describe('#getUsagePlanLogicalId()', () => {
-    it('should return ApiGateway usage plan logical id', () => {
+    it('should return the default ApiGateway usage plan logical id', () => {
       expect(sdk.naming.getUsagePlanLogicalId())
         .to.equal('ApiGatewayUsagePlan');
     });
+
+    it('should return the named ApiGateway usage plan logical id', () => {
+      expect(sdk.naming.getUsagePlanLogicalId('free'))
+        .to.equal('ApiGatewayUsagePlanFree');
+    });
   });
 
-  describe('#getUsagePlanKeyLogicalId(keyIndex)', () => {
+  describe('#getUsagePlanKeyLogicalId()', () => {
     it('should produce the given index with ApiGatewayUsagePlanKey as a prefix', () => {
       expect(sdk.naming.getUsagePlanKeyLogicalId(1)).to.equal('ApiGatewayUsagePlanKey1');
     });
+
+    it('should support API Key names', () => {
+      expect(sdk.naming.getUsagePlanKeyLogicalId(1, 'free'))
+        .to.equal('ApiGatewayUsagePlanKeyFree1');
+    });
   });
 
   describe('#getStageLogicalId()', () => {

lib/plugins/aws/package/compile/events/apiGateway/lib/apiKeys.js

@@ -3,37 +3,59 @@
 const _ = require('lodash');
 const BbPromise = require('bluebird');
 
+function createApiKeyResource(that, apiKey) {
+  const resourceTemplate = {
+    Type: 'AWS::ApiGateway::ApiKey',
+    Properties: {
+      Enabled: true,
+      Name: apiKey,
+      StageKeys: [{
+        RestApiId: that.provider.getApiGatewayRestApiId(),
+        StageName: that.provider.getStage(),
+      }],
+    },
+    DependsOn: that.apiGatewayDeploymentLogicalId,
+  };
+
+  return _.cloneDeep(resourceTemplate);
+}
+
 module.exports = {
   compileApiKeys() {
     if (this.serverless.service.provider.apiKeys) {
       if (!Array.isArray(this.serverless.service.provider.apiKeys)) {
         throw new this.serverless.classes.Error('apiKeys property must be an array');
       }
 
-      _.forEach(this.serverless.service.provider.apiKeys, (apiKey, i) => {
-        const apiKeyNumber = i + 1;
+      const resources = this.serverless.service.provider.compiledCloudFormationTemplate.Resources;
+      let keyNumber = 0;
 
-        if (typeof apiKey !== 'string') {
-          throw new this.serverless.classes.Error('API Keys must be strings');
+      _.forEach(this.serverless.service.provider.apiKeys, (apiKeyDefinition) => {
+        // if multiple API key types are used
+        if (_.isObject(apiKeyDefinition)) {
+          keyNumber = 0;
+          const name = Object.keys(apiKeyDefinition)[0];
+          _.forEach(apiKeyDefinition[name], (key) => {
+            if (!_.isString(key)) {
+              throw new this.serverless.classes.Error('API keys must be strings');
+            }
+            keyNumber += 1;
+            const apiKeyLogicalId = this.provider.naming
+              .getApiKeyLogicalId(keyNumber, name);
+            const resourceTemplate = createApiKeyResource(this, key);
+            _.merge(resources, {
+              [apiKeyLogicalId]: resourceTemplate,
+            });
+          });
+        } else {
+          keyNumber += 1;
+          const apiKeyLogicalId = this.provider.naming
+            .getApiKeyLogicalId(keyNumber);
+          const resourceTemplate = createApiKeyResource(this, apiKeyDefinition);
+          _.merge(resources, {
+            [apiKeyLogicalId]: resourceTemplate,
+          });
         }
-
-        const apiKeyLogicalId = this.provider.naming
-          .getApiKeyLogicalId(apiKeyNumber);
-
-        _.merge(this.serverless.service.provider.compiledCloudFormationTemplate.Resources, {
-          [apiKeyLogicalId]: {
-            Type: 'AWS::ApiGateway::ApiKey',
-            Properties: {
-              Enabled: true,
-              Name: apiKey,
-              StageKeys: [{
-                RestApiId: this.provider.getApiGatewayRestApiId(),
-                StageName: this.provider.getStage(),
-              }],
-            },
-            DependsOn: this.apiGatewayDeploymentLogicalId,
-          },
-        });
       });
     }
     return BbPromise.resolve();