Added support for Shared API Gateway

vlewin · vlewin · commit 3fd93dabbfea · 2018-07-10T21:05:21.000+02:00
diff --git a/lib/deploy/events/apiGateway/deployment.js b/lib/deploy/events/apiGateway/deployment.js
@@ -12,7 +12,7 @@ module.exports = {
       [this.apiGatewayDeploymentLogicalId]: {
         Type: 'AWS::ApiGateway::Deployment',
         Properties: {
-          RestApiId: { Ref: this.apiGatewayRestApiLogicalId },
+          RestApiId: this.provider.getApiGatewayRestApiId(),
           StageName: this.options.stage,
         },
         DependsOn: this.apiGatewayMethodLogicalIds,
@@ -26,7 +26,7 @@ module.exports = {
           'Fn::Join': ['',
             [
               'https://',
-              { Ref: this.apiGatewayRestApiLogicalId },
+              this.provider.getApiGatewayRestApiId(),
               `.execute-api.${this.options.region}.amazonaws.com/${this.options.stage}`,
             ],
           ],
diff --git a/lib/deploy/events/apiGateway/methods.js b/lib/deploy/events/apiGateway/methods.js
@@ -20,7 +20,7 @@ module.exports = {
           AuthorizationType: 'NONE',
           ApiKeyRequired: Boolean(event.http.private),
           ResourceId: resourceId,
-          RestApiId: { Ref: this.apiGatewayRestApiLogicalId },
+          RestApiId: this.provider.getApiGatewayRestApiId(),
         },
       };
 
diff --git a/lib/deploy/events/apiGateway/resources.js b/lib/deploy/events/apiGateway/resources.js
@@ -6,65 +6,248 @@ const _ = require('lodash');
 module.exports = {
 
   compileResources() {
-    const resourcePaths = this.getResourcePaths();
+    this.apiGatewayResources = this.getResourcePaths();
 
-    this.apiGatewayResourceNames = {};
-    this.apiGatewayResourceLogicalIds = {};
+    // ['users', 'users/create', 'users/create/something']
+    _.keys(this.apiGatewayResources).forEach((path) => {
+      const resource = this.apiGatewayResources[path];
+      if (resource.resourceId) {
+        return;
+      }
 
-    resourcePaths.forEach(path => {
-      const pathArray = path.split('/');
-      const resourceName = this.provider.naming.normalizePath(path);
-      const resourceLogicalId = this.provider.naming.getResourceLogicalId(path);
-      const pathPart = pathArray.pop();
-      const parentPath = pathArray.join('/');
-      const parentRef = this.getResourceId(parentPath);
+      resource.resourceLogicalId = this.provider.naming.getResourceLogicalId(path);
+      resource.resourceId = { Ref: resource.resourceLogicalId };
 
-      this.apiGatewayResourceNames[path] = resourceName;
-      this.apiGatewayResourceLogicalIds[path] = resourceLogicalId;
+      const parentRef = resource.parent
+        ? resource.parent.resourceId : this.getResourceId();
 
       _.merge(this.serverless.service.provider.compiledCloudFormationTemplate.Resources, {
-        [resourceLogicalId]: {
+        [resource.resourceLogicalId]: {
           Type: 'AWS::ApiGateway::Resource',
           Properties: {
             ParentId: parentRef,
-            PathPart: pathPart,
-            RestApiId: { Ref: this.apiGatewayRestApiLogicalId },
+            PathPart: resource.pathPart,
+            RestApiId: this.provider.getApiGatewayRestApiId(),
           },
         },
       });
     });
+
     return BbPromise.resolve();
   },
 
+  combineResourceTrees(trees) {
+    const self = this;
+
+    function getNodePaths(result, node) {
+      const r = result;
+      r[node.path] = node;
+      if (!node.name) {
+        r[node.path].name = self.provider.naming.normalizePath(node.path);
+      }
+
+      node.children.forEach((child) => getNodePaths(result, child));
+    }
+
+    return _.reduce(trees, (result, tree) => {
+      getNodePaths(result, tree);
+      return result;
+    }, {});
+  },
+
   getResourcePaths() {
-    const paths = _.reduce(this.pluginhttpValidated.events, (resourcePaths, event) => {
-      let path = event.http.path;
+    const trees = [];
+    const predefinedResourceNodes = [];
+    const methodNodes = [];
+    const predefinedResources = this.provider.getApiGatewayPredefinedResources();
+
+
+    function cutBranch(node) {
+      if (!node.parent) {
+        return;
+      }
+
+      const n = node;
+      if (node.parent.children.length <= 1) {
+        n.parent.children = [];
+      } else {
+        n.parent.children = node.parent.children.filter((c) => c.path !== n.path);
+        n.parent.isCut = true;
+      }
+      n.parent = null;
+    }
+
+    // organize all resource paths into N-ary tree
+    function applyResource(resource, isMethod) {
+      let root;
+      let parent;
+      let currentPath;
+      const path = resource.path.replace(/^\//, '').replace(/\/$/, '');
+      const pathParts = path.split('/');
+
+      function applyNodeResource(node, parts, index) {
+        const n = node;
+        if (index === parts.length - 1) {
+          n.name = resource.name;
+          if (resource.resourceId) {
+            n.resourceId = resource.resourceId;
+            if (_.every(predefinedResourceNodes, (iter) => iter.path !== n.path)) {
+              predefinedResourceNodes.push(node);
+            }
+          }
+          if (isMethod && !node.hasMethod) {
+            n.hasMethod = true;
+            if (_.every(methodNodes, (iter) => iter.path !== n.path)) {
+              methodNodes.push(node);
+            }
+          }
+        }
+
+        parent = node;
+      }
+
+      pathParts.forEach((pathPart, index) => {
+        currentPath = currentPath ? `${currentPath}/${pathPart}` : pathPart;
+        root = root || _.find(trees, (node) => node.path === currentPath);
+        parent = parent || root;
+
+        let node;
+        if (parent) {
+          if (parent.path === currentPath) {
+            applyNodeResource(parent, pathParts, index);
+            return;
+          } else if (parent.children.length > 0) {
+            node = _.find(parent.children, (n) => n.path === currentPath);
+            if (node) {
+              applyNodeResource(node, pathParts, index);
+              return;
+            }
+          }
+        }
+
+        node = {
+          path: currentPath,
+          pathPart,
+          parent,
+
+          level: index,
+          children: [],
+        };
+
+        if (parent) {
+          parent.children.push(node);
+        }
+
+        if (!root) {
+          root = node;
+          trees.push(root);
+        }
+
+        applyNodeResource(node, pathParts, index);
+      });
+    }
+
+    predefinedResources.forEach(applyResource);
+    this.pluginhttpValidated.events.forEach((event) => {
+      if (event.http.path) {
+        applyResource(event.http, true);
+      }
+    });
+
+    // if predefinedResources array is empty, return all paths
+    if (predefinedResourceNodes.length === 0) {
+      return this.combineResourceTrees(trees);
+    }
+
+    // if all methods have resource ID already, no need to validate resource trees
+    if (_.every(this.pluginhttpValidated.events, (event) =>
+        _.some(predefinedResourceNodes, (node) =>
+          node.path === event.http.path))) {
+      return _.reduce(predefinedResources, (resourceMap, resource) => {
+        const r = resourceMap;
+        r[resource.path] = resource;
+
+        if (!resource.name) {
+          r[resource.path].name = this.provider.naming.normalizePath(resource.path);
+        }
+        return r;
+      }, {});
+    }
+
+    // cut resource branches from trees
+    const sortedResourceNodes = _.sortBy(predefinedResourceNodes,
+      node => node.level);
+    const validatedTrees = [];
+
+    for (let i = sortedResourceNodes.length - 1; i >= 0; i--) {
+      const node = sortedResourceNodes[i];
+      let parent = node;
 
-      while (path !== '') {
-        if (resourcePaths.indexOf(path) === -1) {
-          resourcePaths.push(path);
+      while (parent && parent.parent) {
+        if (parent.parent.hasMethod && !parent.parent.resourceId) {
+          throw new Error(`Resource ID for path ${parent.parent.path} is required`);
         }
 
-        const splittedPath = path.split('/');
-        splittedPath.pop();
-        path = splittedPath.join('/');
+        if (parent.parent.resourceId || parent.parent.children.length > 1) {
+          cutBranch(parent);
+          break;
+        }
+
+        parent = parent.parent;
       }
-      return resourcePaths;
-    }, []);
-    return _.sortBy(paths, path => path.split('/').length);
+    }
+
+    // get branches that begin from root resource
+    methodNodes.forEach((node) => {
+      let iter = node;
+      while (iter) {
+        if (iter.resourceId) {
+          cutBranch(iter);
+          if (_.every(validatedTrees, (t) => t.path !== node.path)) {
+            validatedTrees.push(iter);
+          }
+
+          break;
+        }
+
+        if (iter.isCut || (!iter.parent && iter.level > 0)) {
+          throw new Error(`Resource ID for path ${iter.path} is required`);
+        }
+
+        if (!iter.parent) {
+          validatedTrees.push(iter);
+          break;
+        }
+
+        iter = iter.parent;
+      }
+    });
+
+    return this.combineResourceTrees(validatedTrees);
   },
 
   getResourceId(path) {
-    if (path === '') {
-      return { 'Fn::GetAtt': [this.apiGatewayRestApiLogicalId, 'RootResourceId'] };
+    if (!path) {
+      return this.provider.getApiGatewayRestApiRootResourceId();
+    }
+
+    if (!this.apiGatewayResources || !this.apiGatewayResources[path]) {
+      throw new Error(`Can not find API Gateway resource from path ${path}`);
     }
-    return { Ref: this.apiGatewayResourceLogicalIds[path] };
+
+    if (!this.apiGatewayResources[path].resourceId
+      && this.apiGatewayResources[path].resourceLogicalId) {
+      this.apiGatewayResources[path].resourceId =
+          { Ref: this.apiGatewayResources[path].resourceLogicalId };
+    }
+    return this.apiGatewayResources[path].resourceId;
   },
 
   getResourceName(path) {
-    if (path === '') {
+    if (path === '' || !this.apiGatewayResources) {
       return '';
     }
-    return this.apiGatewayResourceNames[path];
+
+    return this.apiGatewayResources[path].name;
   },
 };
diff --git a/lib/deploy/events/apiGateway/restApi.js b/lib/deploy/events/apiGateway/restApi.js
@@ -5,17 +5,55 @@ const BbPromise = require('bluebird');
 
 module.exports = {
   compileRestApi() {
+    if (this.serverless.service.provider.apiGateway &&
+      this.serverless.service.provider.apiGateway.restApiId) {
+      return BbPromise.resolve();
+    }
+
     this.apiGatewayRestApiLogicalId = this.provider.naming.getRestApiLogicalId();
 
+    let endpointType = 'EDGE';
+
+    if (this.serverless.service.provider.endpointType) {
+      const validEndpointTypes = ['REGIONAL', 'EDGE', 'PRIVATE'];
+      endpointType = this.serverless.service.provider.endpointType;
+
+      if (typeof endpointType !== 'string') {
+        throw new this.serverless.classes.Error('endpointType must be a string');
+      }
+
+
+      if (!_.includes(validEndpointTypes, endpointType.toUpperCase())) {
+        const message = 'endpointType must be one of "REGIONAL" or "EDGE" or "PRIVATE". ' +
+                        `You provided ${endpointType}.`;
+        throw new this.serverless.classes.Error(message);
+      }
+      endpointType = endpointType.toUpperCase();
+    }
+
     _.merge(this.serverless.service.provider.compiledCloudFormationTemplate.Resources, {
       [this.apiGatewayRestApiLogicalId]: {
         Type: 'AWS::ApiGateway::RestApi',
         Properties: {
           Name: this.provider.naming.getApiGatewayName(),
+          EndpointConfiguration: {
+            Types: [endpointType],
+          },
         },
       },
     });
 
+    if (!_.isEmpty(this.serverless.service.provider.resourcePolicy)) {
+      const policy = {
+        Version: '2012-10-17',
+        Statement: this.serverless.service.provider.resourcePolicy,
+      };
+      _.merge(this.serverless.service.provider.compiledCloudFormationTemplate
+          .Resources[this.apiGatewayRestApiLogicalId].Properties, {
+            Policy: policy,
+          });
+    }
+
     return BbPromise.resolve();
   },
 };
