fix(aws-apigateway): make LambdaRestApi proxy by default (#963)

The LambdaRestApi construct now proxies all paths and methods by
default, which can be switched off using `proxy: false`.

BREAKING CHANGE: specifying a path no longer works. If you used to
provide a '/', remove it. Otherwise, you will have to supply `proxy: false`
and construct more complex resource paths yourself.

Fixes #959.

packages/@aws-cdk/aws-apigateway/README.md

@@ -34,24 +34,24 @@ book.addMethod('DELETE');
 A very common practice is to use Amazon API Gateway with AWS Lambda as the
 backend integration. The `LambdaRestApi` construct makes it easy:
 
-The following code defines a REST API that uses a greedy `{proxy+}` resource
-mounted under `/api/v1` and integrates all methods (`"ANY"`) with the specified
-AWS Lambda function:
+The following code defines a REST API that routes all requests to the
+specified AWS Lambda function:
 
 ```ts
 const backend = new lambda.Function(...);
 new apigateway.LambdaRestApi(this, 'myapi', {
   handler: backend,
-  proxyPath: '/api/v1'
 });
 ```
 
-If `proxyPath` is not defined, you will have to explicitly define the API model:
+You can also supply `proxy: false`, in which case you will have to explicitly
+define the API model:
 
 ```ts
 const backend = new lambda.Function(...);
 const api = new apigateway.LambdaRestApi(this, 'myapi', {
-  handler: backend
+  handler: backend,
+  proxy: false
 });
 
 const items = api.root.addResource('items');

packages/@aws-cdk/aws-apigateway/lib/lambda-api.ts

@@ -1,6 +1,8 @@
 import lambda = require('@aws-cdk/aws-lambda');
 import cdk = require('@aws-cdk/cdk');
 import { LambdaIntegration } from './integrations';
+import { Method } from './method';
+import { ProxyResource, Resource } from './resource';
 import { RestApi, RestApiProps } from './restapi';
 
 export interface LambdaRestApiProps {
@@ -13,15 +15,14 @@ export interface LambdaRestApiProps {
   handler: lambda.Function;
 
   /**
-   * An API path for a greedy proxy with an "ANY" method, which will route all
-   * requests under that path to the defined handler.
+   * If true, route all requests to the Lambda Function
    *
-   * If not defined, you will need to explicitly define the API model using
+   * If set to false, you will need to explicitly define the API model using
    * `addResource` and `addMethod` (or `addProxy`).
    *
-   * @default undefined
+   * @default true
    */
-  proxyPath?: string;
+  proxy?: boolean;
 
   /**
    * Further customization of the REST API.
@@ -49,16 +50,25 @@ export class LambdaRestApi extends RestApi {
       ...props.options
     });
 
-    // if proxyPath is specified, add a proxy at the specified path
-    // we will need to create all resources along the path.
-    const proxyPath = props.proxyPath;
-    if (proxyPath) {
-      const route = proxyPath.split('/').filter(x => x);
-      let curr = this.root;
-      for (const part of route) {
-        curr = curr.addResource(part);
-      }
-      curr.addProxy();
+    if (props.proxy !== false) {
+      this.root.addProxy();
+
+      // Make sure users cannot call any other resource adding function
+      this.root.addResource = addResourceThrows;
+      this.root.addMethod = addMethodThrows;
+      this.root.addProxy = addProxyThrows;
     }
   }
+}
+
+function addResourceThrows(): Resource {
+  throw new Error(`Cannot call 'addResource' on a proxying LambdaRestApi; set 'proxy' to false`);
+}
+
+function addMethodThrows(): Method {
+  throw new Error(`Cannot call 'addMethod' on a proxying LambdaRestApi; set 'proxy' to false`);
+}
+
+function addProxyThrows(): ProxyResource {
+  throw new Error(`Cannot call 'addProxy' on a proxying LambdaRestApi; set 'proxy' to false`);
 }

packages/@aws-cdk/aws-apigateway/lib/resource.ts

@@ -171,6 +171,8 @@ export class ProxyResource extends Resource {
    */
   public readonly anyMethod?: Method;
 
+  private readonly parentResource: IRestApiResource;
+
   constructor(parent: cdk.Construct, id: string, props: ProxyResourceProps) {
     super(parent, id, {
       parent: props.parent,
@@ -179,11 +181,22 @@ export class ProxyResource extends Resource {
       defaultMethodOptions: props.defaultMethodOptions,
     });
 
+    this.parentResource = props.parent;
+
     const anyMethod = props.anyMethod !== undefined ? props.anyMethod : true;
     if (anyMethod) {
       this.anyMethod = this.addMethod('ANY');
     }
   }
+
+  public addMethod(httpMethod: string, integration?: Integration, options?: MethodOptions): Method {
+    // In case this proxy is mounted under the root, also add this method to
+    // the root so that empty paths are proxied as well.
+    if (this.parentResource.resourcePath === '/') {
+      this.parentResource.addMethod(httpMethod);
+    }
+    return super.addMethod(httpMethod, integration, options);
+  }
 }
 
 function validateResourcePathPart(part: string) {

packages/@aws-cdk/aws-apigateway/test/test.lambda-api.ts

@@ -18,9 +18,14 @@ export = {
     });
 
     // WHEN
-    new apigw.LambdaRestApi(stack, 'lambda-rest-api', { handler, proxyPath: '/' });
+    const api = new apigw.LambdaRestApi(stack, 'lambda-rest-api', { handler });
 
-    // THEN
+    // THEN -- can't customize further
+    test.throws(() => {
+      api.root.addResource('cant-touch-this');
+    });
+
+    // THEN -- template proxies everything
     expect(stack).to(haveResource('AWS::ApiGateway::Resource', {
       "PathPart": "{proxy+}"
     }));
@@ -81,33 +86,7 @@ export = {
     test.done();
   },
 
-  'proxyPath can be used to attach the proxy to any route'(test: Test) {
-    // GIVEN
-    const stack = new cdk.Stack();
-
-    const handler = new lambda.Function(stack, 'handler', {
-      handler: 'index.handler',
-      code: lambda.Code.inline('boom'),
-      runtime: lambda.Runtime.NodeJS610,
-    });
-
-    // WHEN
-    new apigw.LambdaRestApi(stack, 'lambda-rest-api', {
-      handler,
-      proxyPath: '/backend/v2'
-    });
-
-    // THEN
-    expect(stack).to(haveResource('AWS::ApiGateway::Method', {
-      "ResourceId": {
-        "Ref": "lambdarestapibackendv2proxyC4980BD5"
-      }
-    }));
-
-    test.done();
-  },
-
-  'when "proxyPath" is not specified, users need to define the model'(test: Test) {
+  'when "proxy" is set to false, users need to define the model'(test: Test) {
     // GIVEN
     const stack = new cdk.Stack();
 
@@ -118,7 +97,7 @@ export = {
     });
 
     // WHEN
-    const api = new apigw.LambdaRestApi(stack, 'lambda-rest-api', { handler });
+    const api = new apigw.LambdaRestApi(stack, 'lambda-rest-api', { handler, proxy: false });
 
     const tasks = api.root.addResource('tasks');
     tasks.addMethod('GET');
@@ -162,5 +141,5 @@ export = {
     }), /Cannot specify \"options\.defaultIntegration\" since Lambda integration is automatically defined/);
 
     test.done();
-  }
+  },
 };