@aws-solutions-constructs/core 1.124.0 → 1.128.0

package/index.d.ts

@@ -10,6 +10,8 @@
  *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
  *  and limitations under the License.
  */
+export * from './lib/alb-defaults';
+export * from './lib/alb-helper';
 export * from './lib/apigateway-defaults';
 export * from './lib/apigateway-helper';
 export * from './lib/dynamodb-table-defaults';

package/index.js

@@ -22,6 +22,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/alb-defaults"), exports);
+__exportStar(require("./lib/alb-helper"), exports);
 __exportStar(require("./lib/apigateway-defaults"), exports);
 __exportStar(require("./lib/apigateway-helper"), exports);
 __exportStar(require("./lib/dynamodb-table-defaults"), exports);
@@ -75,4 +77,4 @@ __exportStar(require("./lib/ssm-string-parameter-helper"), exports);
 __exportStar(require("./lib/eventbridge-helper"), exports);
 __exportStar(require("./lib/waf-defaults"), exports);
 __exportStar(require("./lib/waf-helper"), exports);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/alb-defaults.d.ts

@@ -0,0 +1,14 @@
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import * as elb from "@aws-cdk/aws-elasticloadbalancingv2";
+export declare function DefaultListenerProps(loadBalancer: elb.ApplicationLoadBalancer): elb.ApplicationListenerProps;

package/lib/alb-defaults.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultListenerProps = void 0;
+const elb = require("@aws-cdk/aws-elasticloadbalancingv2");
+function DefaultListenerProps(loadBalancer) {
+    return {
+        loadBalancer,
+        protocol: elb.ApplicationProtocol.HTTPS,
+    };
+}
+exports.DefaultListenerProps = DefaultListenerProps;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxiLWRlZmF1bHRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYWxiLWRlZmF1bHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7R0FXRzs7O0FBRUgsMkRBQTJEO0FBRTNELFNBQWdCLG9CQUFvQixDQUFDLFlBQXlDO0lBQzVFLE9BQU87UUFDTCxZQUFZO1FBQ1osUUFBUSxFQUFFLEdBQUcsQ0FBQyxtQkFBbUIsQ0FBQyxLQUFLO0tBQ3hDLENBQUM7QUFDSixDQUFDO0FBTEQsb0RBS0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqICBDb3B5cmlnaHQgMjAyMSBBbWF6b24uY29tLCBJbmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqICBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpLiBZb3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlXG4gKiAgd2l0aCB0aGUgTGljZW5zZS4gQSBjb3B5IG9mIHRoZSBMaWNlbnNlIGlzIGxvY2F0ZWQgYXRcbiAqXG4gKiAgICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqICBvciBpbiB0aGUgJ2xpY2Vuc2UnIGZpbGUgYWNjb21wYW55aW5nIHRoaXMgZmlsZS4gVGhpcyBmaWxlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuICdBUyBJUycgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFU1xuICogIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGV4cHJlc3Mgb3IgaW1wbGllZC4gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zXG4gKiAgYW5kIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCAqIGFzIGVsYiBmcm9tIFwiQGF3cy1jZGsvYXdzLWVsYXN0aWNsb2FkYmFsYW5jaW5ndjJcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIERlZmF1bHRMaXN0ZW5lclByb3BzKGxvYWRCYWxhbmNlcjogZWxiLkFwcGxpY2F0aW9uTG9hZEJhbGFuY2VyKTogZWxiLkFwcGxpY2F0aW9uTGlzdGVuZXJQcm9wcyB7XG4gIHJldHVybiB7XG4gICAgbG9hZEJhbGFuY2VyLFxuICAgIHByb3RvY29sOiBlbGIuQXBwbGljYXRpb25Qcm90b2NvbC5IVFRQUyxcbiAgfTtcbn0iXX0=

package/lib/alb-helper.d.ts

@@ -0,0 +1,21 @@
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import * as elb from "@aws-cdk/aws-elasticloadbalancingv2";
+import { Construct } from "@aws-cdk/core";
+import * as ec2 from "@aws-cdk/aws-ec2";
+import * as s3 from "@aws-cdk/aws-s3";
+import * as lambda from "@aws-cdk/aws-lambda";
+export declare function ObtainAlb(scope: Construct, id: string, vpc: ec2.IVpc, publicApi: boolean, existingLoadBalancerInterface?: elb.ApplicationLoadBalancer, loadBalancerProps?: elb.ApplicationLoadBalancerProps | any, logAccessLogs?: boolean, loggingBucketProps?: s3.BucketProps): elb.ApplicationLoadBalancer;
+export declare function AddListener(scope: Construct, loadBalancer: elb.ApplicationLoadBalancer, targetGroup: elb.ApplicationTargetGroup, listenerProps: elb.ApplicationListenerProps | any): elb.ApplicationListener;
+export declare function CreateLambdaTargetGroup(scope: Construct, id: string, lambdaFunction: lambda.IFunction, targetProps?: elb.ApplicationTargetGroupProps): elb.ApplicationTargetGroup;
+export declare function AddTarget(scope: Construct, targetGroup: elb.ApplicationTargetGroup, listener: elb.ApplicationListener, ruleProps?: elb.AddRuleProps): void;

package/lib/alb-helper.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddTarget = exports.CreateLambdaTargetGroup = exports.AddListener = exports.ObtainAlb = void 0;
+const elb = require("@aws-cdk/aws-elasticloadbalancingv2");
+const aws_elasticloadbalancingv2_1 = require("@aws-cdk/aws-elasticloadbalancingv2");
+const elbt = require("@aws-cdk/aws-elasticloadbalancingv2-targets");
+const utils_1 = require("./utils");
+const alb_defaults_1 = require("./alb-defaults");
+const s3_bucket_helper_1 = require("./s3-bucket-helper");
+const s3_bucket_defaults_1 = require("./s3-bucket-defaults");
+//  Returns the correct ALB Load Balancer to use in this construct, either an existing
+//  one provided as an argument or create  new one otherwise.
+function ObtainAlb(scope, id, vpc, publicApi, existingLoadBalancerInterface, loadBalancerProps, logAccessLogs, loggingBucketProps) {
+    let loadBalancer;
+    if (existingLoadBalancerInterface) {
+        loadBalancer = existingLoadBalancerInterface;
+    }
+    else {
+        const consolidatedProps = loadBalancerProps
+            ? utils_1.overrideProps(loadBalancerProps, { vpc, internetFacing: publicApi })
+            : { vpc, internetFacing: publicApi };
+        loadBalancer = new elb.ApplicationLoadBalancer(scope, `${id}-alb`, consolidatedProps);
+        if (logAccessLogs === undefined || logAccessLogs === true) {
+            const consolidatedLoggingBucketProps = loggingBucketProps
+                ? utils_1.overrideProps(s3_bucket_defaults_1.DefaultLoggingBucketProps(), loggingBucketProps)
+                : s3_bucket_defaults_1.DefaultLoggingBucketProps();
+            const loggingBucket = s3_bucket_helper_1.createAlbLoggingBucket(scope, id, consolidatedLoggingBucketProps);
+            loadBalancer.logAccessLogs(loggingBucket);
+        }
+    }
+    return loadBalancer;
+}
+exports.ObtainAlb = ObtainAlb;
+function AddListener(scope, loadBalancer, targetGroup, listenerProps) {
+    var _a;
+    let consolidatedListenerProps;
+    consolidatedListenerProps = utils_1.overrideProps(alb_defaults_1.DefaultListenerProps(loadBalancer), listenerProps);
+    //   create the listener
+    const listener = new elb.ApplicationListener(scope, "listener", consolidatedListenerProps);
+    loadBalancer.listeners.push(listener);
+    if (consolidatedListenerProps.protocol === elb.ApplicationProtocol.HTTP) {
+        // This will use core.printWarning in the actual construct
+        utils_1.printWarning("AWS recommends encrypting traffic to an Application Load Balancer using HTTPS.");
+        if (((_a = listenerProps.certificates) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            throw new Error("HTTP listeners cannot use a certificate");
+        }
+    }
+    else {
+        if (!listenerProps.certificates || listenerProps.certificates.length === 0) {
+            throw new Error("A listener using HTTPS protocol requires a certificate");
+        }
+        listener.addCertificates("listener-cert-add", listenerProps.certificates);
+    }
+    if (consolidatedListenerProps.protocol === elb.ApplicationProtocol.HTTPS) {
+        const opt = {
+            port: "443",
+            protocol: "HTTPS",
+        };
+        const httpListener = new elb.ApplicationListener(scope, "redirect-listener", {
+            loadBalancer,
+            protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP,
+            defaultAction: aws_elasticloadbalancingv2_1.ListenerAction.redirect(opt),
+        });
+        loadBalancer.listeners.push(httpListener);
+    }
+    AddTarget(scope, targetGroup, listener);
+    return listener;
+}
+exports.AddListener = AddListener;
+function CreateLambdaTargetGroup(scope, id, lambdaFunction, targetProps) {
+    const lambdaTarget = new elbt.LambdaTarget(lambdaFunction);
+    return new elb.ApplicationTargetGroup(scope, `${id}-tg`, {
+        targets: [lambdaTarget],
+        targetGroupName: targetProps ? targetProps.targetGroupName : undefined,
+        healthCheck: targetProps ? targetProps.healthCheck : undefined
+    });
+}
+exports.CreateLambdaTargetGroup = CreateLambdaTargetGroup;
+function AddTarget(scope, targetGroup, listener, ruleProps) {
+    // AddRuleProps includes conditions and priority, combine that with targetGroups and
+    // we can assemble AddApplicationTargetGroupProps
+    if (ruleProps) {
+        const consolidatedTargetProps = utils_1.overrideProps(ruleProps, { targetGroups: [targetGroup] });
+        listener.addTargetGroups(`${scope.node.id}-targets`, consolidatedTargetProps);
+    }
+    else {
+        listener.addTargetGroups("targets", {
+            targetGroups: [targetGroup],
+        });
+    }
+    return;
+}
+exports.AddTarget = AddTarget;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alb-helper.js","sourceRoot":"","sources":["alb-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport * as elb from \"@aws-cdk/aws-elasticloadbalancingv2\";\nimport { Construct } from \"@aws-cdk/core\";\nimport * as ec2 from \"@aws-cdk/aws-ec2\";\nimport * as s3 from \"@aws-cdk/aws-s3\";\nimport * as lambda from \"@aws-cdk/aws-lambda\";\nimport { ApplicationProtocol, ListenerAction, } from \"@aws-cdk/aws-elasticloadbalancingv2\";\nimport * as elbt from \"@aws-cdk/aws-elasticloadbalancingv2-targets\";\nimport { overrideProps, printWarning } from \"./utils\";\nimport { DefaultListenerProps } from \"./alb-defaults\";\nimport { createAlbLoggingBucket } from \"./s3-bucket-helper\";\nimport { DefaultLoggingBucketProps } from \"./s3-bucket-defaults\";\n\n//  Returns the correct ALB Load Balancer to use in this construct, either an existing\n//  one provided as an argument or create  new one otherwise.\nexport function ObtainAlb(\n  scope: Construct,\n  id: string,\n  vpc: ec2.IVpc,\n  publicApi: boolean,\n  existingLoadBalancerInterface?: elb.ApplicationLoadBalancer,\n  loadBalancerProps?: elb.ApplicationLoadBalancerProps | any,\n  logAccessLogs?: boolean,\n  loggingBucketProps?: s3.BucketProps\n): elb.ApplicationLoadBalancer {\n  let loadBalancer: elb.ApplicationLoadBalancer;\n\n  if (existingLoadBalancerInterface) {\n    loadBalancer = existingLoadBalancerInterface;\n  } else {\n    const consolidatedProps = loadBalancerProps\n      ? overrideProps(loadBalancerProps, { vpc, internetFacing: publicApi })\n      : { vpc, internetFacing: publicApi };\n    loadBalancer = new elb.ApplicationLoadBalancer(\n      scope,\n      `${id}-alb`,\n      consolidatedProps\n    );\n    if (logAccessLogs === undefined || logAccessLogs === true) {\n      const consolidatedLoggingBucketProps = loggingBucketProps\n        ? overrideProps(DefaultLoggingBucketProps(), loggingBucketProps)\n        : DefaultLoggingBucketProps();\n      const loggingBucket = createAlbLoggingBucket(scope, id, consolidatedLoggingBucketProps);\n      loadBalancer.logAccessLogs(loggingBucket);\n    }\n  }\n  return loadBalancer;\n}\n\nexport function AddListener(\n  scope: Construct,\n  loadBalancer: elb.ApplicationLoadBalancer,\n  targetGroup: elb.ApplicationTargetGroup,\n  listenerProps: elb.ApplicationListenerProps | any\n): elb.ApplicationListener {\n  let consolidatedListenerProps: elb.ApplicationListenerProps;\n\n  consolidatedListenerProps = overrideProps(\n    DefaultListenerProps(loadBalancer),\n    listenerProps\n  );\n\n  //   create the listener\n  const listener = new elb.ApplicationListener(\n    scope,\n    \"listener\",\n    consolidatedListenerProps\n  );\n  loadBalancer.listeners.push(listener);\n\n  if (consolidatedListenerProps.protocol === elb.ApplicationProtocol.HTTP) {\n    // This will use core.printWarning in the actual construct\n    printWarning(\n      \"AWS recommends encrypting traffic to an Application Load Balancer using HTTPS.\"\n    );\n    if (listenerProps.certificates?.length > 0) {\n      throw new Error(\"HTTP listeners cannot use a certificate\");\n    }\n  } else {\n    if (!listenerProps.certificates || listenerProps.certificates.length === 0) {\n      throw new Error(\"A listener using HTTPS protocol requires a certificate\");\n    }\n\n    listener.addCertificates(\"listener-cert-add\", listenerProps.certificates);\n  }\n\n  if (consolidatedListenerProps.protocol === elb.ApplicationProtocol.HTTPS) {\n    const opt: elb.RedirectOptions = {\n      port: \"443\",\n      protocol: \"HTTPS\",\n    };\n\n    const httpListener = new elb.ApplicationListener(\n      scope,\n      \"redirect-listener\",\n      {\n        loadBalancer,\n        protocol: ApplicationProtocol.HTTP,\n        defaultAction: ListenerAction.redirect(opt),\n      }\n    );\n    loadBalancer.listeners.push(httpListener);\n  }\n\n  AddTarget(scope, targetGroup, listener);\n  return listener;\n}\n\nexport function CreateLambdaTargetGroup(\n  scope: Construct,\n  id: string,\n  lambdaFunction: lambda.IFunction,\n  targetProps?: elb.ApplicationTargetGroupProps\n): elb.ApplicationTargetGroup {\n  const lambdaTarget = new elbt.LambdaTarget(lambdaFunction);\n  return new elb.ApplicationTargetGroup(scope, `${id}-tg`, {\n    targets: [lambdaTarget],\n    targetGroupName: targetProps ? targetProps.targetGroupName : undefined,\n    healthCheck: targetProps ? targetProps.healthCheck : undefined\n  });\n}\n\nexport function AddTarget(\n  scope: Construct,\n  targetGroup: elb.ApplicationTargetGroup,\n  listener: elb.ApplicationListener,\n  ruleProps?: elb.AddRuleProps\n) {\n  // AddRuleProps includes conditions and priority, combine that with targetGroups and\n  // we can assemble AddApplicationTargetGroupProps\n  if (ruleProps) {\n    const consolidatedTargetProps = overrideProps(ruleProps, { targetGroups: [targetGroup] });\n    listener.addTargetGroups(`${scope.node.id}-targets`, consolidatedTargetProps);\n  } else {\n    listener.addTargetGroups(\"targets\", {\n      targetGroups: [targetGroup],\n    });\n  }\n  return;\n}\n"]}

package/lib/apigateway-helper.d.ts

@@ -22,26 +22,26 @@ import { Construct } from '@aws-cdk/core';
  * @param _existingLambdaObj - an existing AWS Lambda function.
  * @param apiGatewayProps - (optional) user-specified properties to override the default properties.
  */
-export declare function GlobalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function, apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup];
+export declare function GlobalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function, apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup];
 /**
  * Builds and returns a regional api.RestApi designed to be used with an AWS Lambda function.
  * @param scope - the construct to which the RestApi should be attached to.
  * @param _existingLambdaObj - an existing AWS Lambda function.
  * @param apiGatewayProps - (optional) user-specified properties to override the default properties.
  */
-export declare function RegionalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function, apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup];
+export declare function RegionalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function, apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup];
 /**
  * Builds and returns a standard api.RestApi.
  * @param scope - the construct to which the RestApi should be attached to.
  * @param apiGatewayProps - (optional) user-specified properties to override the default properties.
  */
-export declare function GlobalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup];
+export declare function GlobalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup];
 /**
  * Builds and returns a Regional api.RestApi.
  * @param scope - the construct to which the RestApi should be attached to.
  * @param apiGatewayProps - (optional) user-specified properties to override the default properties.
  */
-export declare function RegionalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup];
+export declare function RegionalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup];
 export interface AddProxyMethodToApiResourceInputParams {
     readonly service: string;
     readonly action?: string;

package/lib/apigateway-helper.js

@@ -79,7 +79,7 @@ function configureLambdaRestApi(scope, defaultApiGatewayProps, apiGatewayProps)
     let _api;
     if (apiGatewayProps) {
         // If property overrides have been provided, incorporate them and deploy
-        const _apiGatewayProps = utils_1.overrideProps(defaultApiGatewayProps, apiGatewayProps);
+        const _apiGatewayProps = utils_1.overrideProps(defaultApiGatewayProps, { ...apiGatewayProps, cloudWatchRole: false });
         _api = new api.LambdaRestApi(scope, 'LambdaRestApi', _apiGatewayProps);
     }
     else {
@@ -87,7 +87,10 @@ function configureLambdaRestApi(scope, defaultApiGatewayProps, apiGatewayProps)
         _api = new api.LambdaRestApi(scope, 'LambdaRestApi', defaultApiGatewayProps);
     }
     // Configure API access logging
-    const cwRole = configureCloudwatchRoleForApi(scope, _api);
+    let cwRole;
+    if ((apiGatewayProps === null || apiGatewayProps === void 0 ? void 0 : apiGatewayProps.cloudWatchRole) !== false) {
+        cwRole = configureCloudwatchRoleForApi(scope, _api);
+    }
     let usagePlanProps = {
         apiStages: [{
                 api: _api,
@@ -120,15 +123,18 @@ function configureRestApi(scope, defaultApiGatewayProps, apiGatewayProps) {
     let _api;
     if (apiGatewayProps) {
         // If property overrides have been provided, incorporate them and deploy
-        const _apiGatewayProps = utils_1.overrideProps(defaultApiGatewayProps, apiGatewayProps);
+        const _apiGatewayProps = utils_1.overrideProps(defaultApiGatewayProps, { ...apiGatewayProps, cloudWatchRole: false });
         _api = new api.RestApi(scope, 'RestApi', _apiGatewayProps);
     }
     else {
         // If no property overrides, deploy using the default configuration
         _api = new api.RestApi(scope, 'RestApi', defaultApiGatewayProps);
     }
+    let cwRole;
     // Configure API access logging
-    const cwRole = configureCloudwatchRoleForApi(scope, _api);
+    if ((apiGatewayProps === null || apiGatewayProps === void 0 ? void 0 : apiGatewayProps.cloudWatchRole) !== false) {
+        cwRole = configureCloudwatchRoleForApi(scope, _api);
+    }
     let usagePlanProps = {
         apiStages: [{
                 api: _api,
@@ -280,4 +286,4 @@ function addProxyMethodToApiResource(params) {
     return apiMethod;
 }
 exports.addProxyMethodToApiResource = addProxyMethodToApiResource;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apigateway-helper.js","sourceRoot":"","sources":["apigateway-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\n// Imports\nimport * as logs from '@aws-cdk/aws-logs';\nimport * as lambda from '@aws-cdk/aws-lambda';\nimport * as cdk from '@aws-cdk/core';\nimport * as api from '@aws-cdk/aws-apigateway';\nimport * as iam from '@aws-cdk/aws-iam';\nimport * as apiDefaults from './apigateway-defaults';\nimport { buildLogGroup } from './cloudwatch-log-group-helper';\nimport { overrideProps, addCfnSuppressRules } from './utils';\nimport { IRole } from '@aws-cdk/aws-iam';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from '@aws-cdk/core';\n\n/**\n * Create and configures access logging for API Gateway resources.\n * @param scope - the construct to which the access logging capabilities should be attached to.\n * @param _api - an existing api.RestApi or api.LambdaRestApi.\n */\nfunction configureCloudwatchRoleForApi(scope: Construct, _api: api.RestApi): iam.Role {\n  // Setup the IAM Role for API Gateway CloudWatch access\n  const restApiCloudwatchRole = new iam.Role(scope, 'LambdaRestApiCloudWatchRole', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),\n    inlinePolicies: {\n      LambdaRestApiCloudWatchRolePolicy: new iam.PolicyDocument({\n        statements: [new iam.PolicyStatement({\n          actions: [\n            'logs:CreateLogGroup',\n            'logs:CreateLogStream',\n            'logs:DescribeLogGroups',\n            'logs:DescribeLogStreams',\n            'logs:PutLogEvents',\n            'logs:GetLogEvents',\n            'logs:FilterLogEvents'\n          ],\n          resources: [`arn:${cdk.Aws.PARTITION}:logs:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:*`]\n        })]\n      })\n    }\n  });\n    // Create and configure AWS::ApiGateway::Account with CloudWatch Role for ApiGateway\n  const CfnApi = _api.node.findChild('Resource') as api.CfnRestApi;\n  const cfnAccount: api.CfnAccount = new api.CfnAccount(scope, 'LambdaRestApiAccount', {\n    cloudWatchRoleArn: restApiCloudwatchRole.roleArn\n  });\n  cfnAccount.addDependsOn(CfnApi);\n\n  // Suppress Cfn Nag warning for APIG\n  const deployment: api.CfnDeployment = _api.latestDeployment?.node.findChild('Resource') as api.CfnDeployment;\n  addCfnSuppressRules(deployment, [\n    {\n      id: 'W45',\n      reason: `ApiGateway has AccessLogging enabled in AWS::ApiGateway::Stage resource, but cfn_nag checkes for it in AWS::ApiGateway::Deployment resource`\n    }\n  ]);\n\n  // Return the CW Role\n  return restApiCloudwatchRole;\n}\n\n/**\n * Creates and configures an api.LambdaRestApi.\n * @param scope - the construct to which the LambdaRestApi should be attached to.\n * @param defaultApiGatewayProps - the default properties for the LambdaRestApi.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nfunction configureLambdaRestApi(scope: Construct, defaultApiGatewayProps: api.LambdaRestApiProps,\n  apiGatewayProps?: api.LambdaRestApiProps): [api.RestApi, iam.Role] {\n\n  // API Gateway doesn't allow both endpointTypes and endpointConfiguration, check whether endPointTypes exists\n  if (apiGatewayProps?.endpointTypes) {\n    throw Error('Solutions Constructs internally uses endpointConfiguration, use endpointConfiguration instead of endpointTypes');\n  }\n\n  // Define the API object\n  let _api: api.RestApi;\n  if (apiGatewayProps) {\n    // If property overrides have been provided, incorporate them and deploy\n    const _apiGatewayProps = overrideProps(defaultApiGatewayProps, apiGatewayProps);\n    _api = new api.LambdaRestApi(scope, 'LambdaRestApi', _apiGatewayProps);\n  } else {\n    // If no property overrides, deploy using the default configuration\n    _api = new api.LambdaRestApi(scope, 'LambdaRestApi', defaultApiGatewayProps);\n  }\n  // Configure API access logging\n  const cwRole = configureCloudwatchRoleForApi(scope, _api);\n\n  let usagePlanProps: api.UsagePlanProps = {\n    apiStages: [{\n      api: _api,\n      stage: _api.deploymentStage\n    }]\n  };\n    // If requireApiKey param is set to true, create a api key & associate to Usage Plan\n  if (apiGatewayProps?.defaultMethodOptions?.apiKeyRequired === true) {\n    const extraParams = { apiKey: _api.addApiKey('ApiKey')};\n    usagePlanProps = Object.assign(usagePlanProps, extraParams);\n  }\n\n  // Configure Usage Plan\n  _api.addUsagePlan('UsagePlan', usagePlanProps);\n\n  // Return the API and CW Role\n  return [_api, cwRole];\n}\n\n/**\n * Creates and configures an api.RestApi.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param defaultApiGatewayProps - the default properties for the RestApi.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nfunction configureRestApi(scope: Construct, defaultApiGatewayProps: api.RestApiProps,\n  apiGatewayProps?: api.RestApiProps): [api.RestApi, iam.Role] {\n\n  // API Gateway doesn't allow both endpointTypes and endpointConfiguration, check whether endPointTypes exists\n  if (apiGatewayProps?.endpointTypes) {\n    throw Error('Solutions Constructs internally uses endpointConfiguration, use endpointConfiguration instead of endpointTypes');\n  }\n\n  // Define the API\n  let _api: api.RestApi;\n  if (apiGatewayProps) {\n    // If property overrides have been provided, incorporate them and deploy\n    const _apiGatewayProps = overrideProps(defaultApiGatewayProps, apiGatewayProps);\n    _api = new api.RestApi(scope, 'RestApi', _apiGatewayProps);\n  } else {\n    // If no property overrides, deploy using the default configuration\n    _api = new api.RestApi(scope, 'RestApi', defaultApiGatewayProps);\n  }\n  // Configure API access logging\n  const cwRole = configureCloudwatchRoleForApi(scope, _api);\n\n  let usagePlanProps: api.UsagePlanProps = {\n    apiStages: [{\n      api: _api,\n      stage: _api.deploymentStage\n    }]\n  };\n\n  // If requireApiKey param is set to true, create a api key & associate to Usage Plan\n  if (apiGatewayProps?.defaultMethodOptions?.apiKeyRequired === true) {\n    const extraParams = { apiKey: _api.addApiKey('ApiKey')};\n    usagePlanProps = Object.assign(usagePlanProps, extraParams);\n  }\n\n  // Configure Usage Plan\n  _api.addUsagePlan('UsagePlan', usagePlanProps);\n\n  // Return the API and CW Role\n  return [_api, cwRole];\n}\n\n/**\n * Builds and returns a global api.RestApi designed to be used with an AWS Lambda function.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _existingLambdaObj - an existing AWS Lambda function.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function GlobalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function,\n  apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultGlobalLambdaRestApiProps(_existingLambdaObj, logGroup);\n  const [restApi, apiCWRole] = configureLambdaRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\n/**\n * Builds and returns a regional api.RestApi designed to be used with an AWS Lambda function.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _existingLambdaObj - an existing AWS Lambda function.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function RegionalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function,\n  apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultRegionalLambdaRestApiProps(_existingLambdaObj, logGroup);\n  const [restApi, apiCWRole] = configureLambdaRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\n/**\n * Builds and returns a standard api.RestApi.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function GlobalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps,\n  logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultGlobalRestApiProps(logGroup);\n  const [restApi, apiCWRole] = configureRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\n/**\n * Builds and returns a Regional api.RestApi.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function RegionalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps,\n  logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultRegionalRestApiProps(logGroup);\n  const [restApi, apiCWRole] = configureRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\nexport interface AddProxyMethodToApiResourceInputParams {\n    readonly service: string,\n    readonly action?: string,\n    readonly path?: string,\n    readonly apiResource: api.IResource,\n    readonly apiMethod: string,\n    readonly apiGatewayRole: IRole,\n    readonly requestTemplate: string,\n    readonly contentType?: string,\n    readonly requestValidator?: api.IRequestValidator,\n    readonly requestModel?: { [contentType: string]: api.IModel; },\n    readonly awsIntegrationProps?: api.AwsIntegrationProps | any,\n    readonly methodOptions?: api.MethodOptions\n}\n\nexport function addProxyMethodToApiResource(params: AddProxyMethodToApiResourceInputParams): api.Method {\n  let baseProps: api.AwsIntegrationProps = {\n    service: params.service,\n    integrationHttpMethod: \"POST\",\n    options: {\n      passthroughBehavior: api.PassthroughBehavior.NEVER,\n      credentialsRole: params.apiGatewayRole,\n      requestParameters: {\n        \"integration.request.header.Content-Type\": params.contentType ? params.contentType : \"'application/json'\"\n      },\n      requestTemplates: {\n        \"application/json\": params.requestTemplate\n      },\n      integrationResponses: [\n        {\n          statusCode: \"200\"\n        },\n        {\n          statusCode: \"500\",\n          responseTemplates: {\n            \"text/html\": \"Error\"\n          },\n          selectionPattern: \"500\"\n        }\n      ]\n    }\n  };\n\n  let extraProps;\n\n  if (params.action) {\n    extraProps = {\n      action: params.action\n    };\n  } else if (params.path) {\n    extraProps = {\n      path: params.path\n    };\n  } else {\n    throw Error('Either action or path is required');\n  }\n\n  // Setup the API Gateway AWS Integration\n  baseProps = Object.assign(baseProps, extraProps);\n  let apiGatewayIntegration;\n  if (params.awsIntegrationProps) {\n    const overridenProps = overrideProps(baseProps, params.awsIntegrationProps);\n    apiGatewayIntegration = new api.AwsIntegration(overridenProps);\n  } else {\n    apiGatewayIntegration = new api.AwsIntegration(baseProps);\n  }\n\n  const defaultMethodOptions = {\n    methodResponses: [\n      {\n        statusCode: \"200\",\n        responseParameters: {\n          \"method.response.header.Content-Type\": true\n        }\n      },\n      {\n        statusCode: \"500\",\n        responseParameters: {\n          \"method.response.header.Content-Type\": true\n        },\n      }\n    ],\n    requestValidator: params.requestValidator,\n    requestModels: params.requestModel\n  };\n\n  let apiMethod;\n  // Setup the API Gateway method\n  if (params.methodOptions) {\n    const overridenProps =  overrideProps(defaultMethodOptions, params.methodOptions);\n    apiMethod = params.apiResource.addMethod(params.apiMethod, apiGatewayIntegration, overridenProps);\n  } else {\n    apiMethod = params.apiResource.addMethod(params.apiMethod, apiGatewayIntegration, defaultMethodOptions);\n  }\n  return apiMethod;\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apigateway-helper.js","sourceRoot":"","sources":["apigateway-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\n// Imports\nimport * as logs from '@aws-cdk/aws-logs';\nimport * as lambda from '@aws-cdk/aws-lambda';\nimport * as cdk from '@aws-cdk/core';\nimport * as api from '@aws-cdk/aws-apigateway';\nimport * as iam from '@aws-cdk/aws-iam';\nimport * as apiDefaults from './apigateway-defaults';\nimport { buildLogGroup } from './cloudwatch-log-group-helper';\nimport { overrideProps, addCfnSuppressRules } from './utils';\nimport { IRole } from '@aws-cdk/aws-iam';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from '@aws-cdk/core';\n\n/**\n * Create and configures access logging for API Gateway resources.\n * @param scope - the construct to which the access logging capabilities should be attached to.\n * @param _api - an existing api.RestApi or api.LambdaRestApi.\n */\nfunction configureCloudwatchRoleForApi(scope: Construct, _api: api.RestApi): iam.Role {\n  // Setup the IAM Role for API Gateway CloudWatch access\n  const restApiCloudwatchRole = new iam.Role(scope, 'LambdaRestApiCloudWatchRole', {\n    assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),\n    inlinePolicies: {\n      LambdaRestApiCloudWatchRolePolicy: new iam.PolicyDocument({\n        statements: [new iam.PolicyStatement({\n          actions: [\n            'logs:CreateLogGroup',\n            'logs:CreateLogStream',\n            'logs:DescribeLogGroups',\n            'logs:DescribeLogStreams',\n            'logs:PutLogEvents',\n            'logs:GetLogEvents',\n            'logs:FilterLogEvents'\n          ],\n          resources: [`arn:${cdk.Aws.PARTITION}:logs:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:*`]\n        })]\n      })\n    }\n  });\n    // Create and configure AWS::ApiGateway::Account with CloudWatch Role for ApiGateway\n  const CfnApi = _api.node.findChild('Resource') as api.CfnRestApi;\n  const cfnAccount: api.CfnAccount = new api.CfnAccount(scope, 'LambdaRestApiAccount', {\n    cloudWatchRoleArn: restApiCloudwatchRole.roleArn\n  });\n  cfnAccount.addDependsOn(CfnApi);\n\n  // Suppress Cfn Nag warning for APIG\n  const deployment: api.CfnDeployment = _api.latestDeployment?.node.findChild('Resource') as api.CfnDeployment;\n  addCfnSuppressRules(deployment, [\n    {\n      id: 'W45',\n      reason: `ApiGateway has AccessLogging enabled in AWS::ApiGateway::Stage resource, but cfn_nag checkes for it in AWS::ApiGateway::Deployment resource`\n    }\n  ]);\n\n  // Return the CW Role\n  return restApiCloudwatchRole;\n}\n\n/**\n * Creates and configures an api.LambdaRestApi.\n * @param scope - the construct to which the LambdaRestApi should be attached to.\n * @param defaultApiGatewayProps - the default properties for the LambdaRestApi.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nfunction configureLambdaRestApi(scope: Construct, defaultApiGatewayProps: api.LambdaRestApiProps,\n  apiGatewayProps?: api.LambdaRestApiProps): [api.RestApi, iam.Role | undefined] {\n\n  // API Gateway doesn't allow both endpointTypes and endpointConfiguration, check whether endPointTypes exists\n  if (apiGatewayProps?.endpointTypes) {\n    throw Error('Solutions Constructs internally uses endpointConfiguration, use endpointConfiguration instead of endpointTypes');\n  }\n\n  // Define the API object\n  let _api: api.RestApi;\n  if (apiGatewayProps) {\n    // If property overrides have been provided, incorporate them and deploy\n    const _apiGatewayProps = overrideProps(defaultApiGatewayProps, { ...apiGatewayProps, cloudWatchRole: false });\n    _api = new api.LambdaRestApi(scope, 'LambdaRestApi', _apiGatewayProps);\n  } else {\n    // If no property overrides, deploy using the default configuration\n    _api = new api.LambdaRestApi(scope, 'LambdaRestApi', defaultApiGatewayProps);\n  }\n  // Configure API access logging\n  let cwRole;\n\n  if (apiGatewayProps?.cloudWatchRole !== false) {\n    cwRole = configureCloudwatchRoleForApi(scope, _api);\n  }\n\n  let usagePlanProps: api.UsagePlanProps = {\n    apiStages: [{\n      api: _api,\n      stage: _api.deploymentStage\n    }]\n  };\n    // If requireApiKey param is set to true, create a api key & associate to Usage Plan\n  if (apiGatewayProps?.defaultMethodOptions?.apiKeyRequired === true) {\n    const extraParams = { apiKey: _api.addApiKey('ApiKey')};\n    usagePlanProps = Object.assign(usagePlanProps, extraParams);\n  }\n\n  // Configure Usage Plan\n  _api.addUsagePlan('UsagePlan', usagePlanProps);\n\n  // Return the API and CW Role\n  return [_api, cwRole];\n}\n\n/**\n * Creates and configures an api.RestApi.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param defaultApiGatewayProps - the default properties for the RestApi.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nfunction configureRestApi(scope: Construct, defaultApiGatewayProps: api.RestApiProps,\n  apiGatewayProps?: api.RestApiProps): [api.RestApi, iam.Role | undefined] {\n\n  // API Gateway doesn't allow both endpointTypes and endpointConfiguration, check whether endPointTypes exists\n  if (apiGatewayProps?.endpointTypes) {\n    throw Error('Solutions Constructs internally uses endpointConfiguration, use endpointConfiguration instead of endpointTypes');\n  }\n\n  // Define the API\n  let _api: api.RestApi;\n  if (apiGatewayProps) {\n    // If property overrides have been provided, incorporate them and deploy\n    const _apiGatewayProps = overrideProps(defaultApiGatewayProps, { ...apiGatewayProps, cloudWatchRole: false });\n    _api = new api.RestApi(scope, 'RestApi', _apiGatewayProps);\n  } else {\n    // If no property overrides, deploy using the default configuration\n    _api = new api.RestApi(scope, 'RestApi', defaultApiGatewayProps);\n  }\n\n  let cwRole;\n\n  // Configure API access logging\n  if (apiGatewayProps?.cloudWatchRole !== false) {\n    cwRole = configureCloudwatchRoleForApi(scope, _api);\n  }\n\n  let usagePlanProps: api.UsagePlanProps = {\n    apiStages: [{\n      api: _api,\n      stage: _api.deploymentStage\n    }]\n  };\n\n  // If requireApiKey param is set to true, create a api key & associate to Usage Plan\n  if (apiGatewayProps?.defaultMethodOptions?.apiKeyRequired === true) {\n    const extraParams = { apiKey: _api.addApiKey('ApiKey')};\n    usagePlanProps = Object.assign(usagePlanProps, extraParams);\n  }\n\n  // Configure Usage Plan\n  _api.addUsagePlan('UsagePlan', usagePlanProps);\n\n  // Return the API and CW Role\n  return [_api, cwRole];\n}\n\n/**\n * Builds and returns a global api.RestApi designed to be used with an AWS Lambda function.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _existingLambdaObj - an existing AWS Lambda function.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function GlobalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function,\n  apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultGlobalLambdaRestApiProps(_existingLambdaObj, logGroup);\n  const [restApi, apiCWRole] = configureLambdaRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\n/**\n * Builds and returns a regional api.RestApi designed to be used with an AWS Lambda function.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _existingLambdaObj - an existing AWS Lambda function.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function RegionalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function,\n  apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultRegionalLambdaRestApiProps(_existingLambdaObj, logGroup);\n  const [restApi, apiCWRole] = configureLambdaRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\n/**\n * Builds and returns a standard api.RestApi.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function GlobalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps,\n  logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultGlobalRestApiProps(logGroup);\n  const [restApi, apiCWRole] = configureRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\n/**\n * Builds and returns a Regional api.RestApi.\n * @param scope - the construct to which the RestApi should be attached to.\n * @param apiGatewayProps - (optional) user-specified properties to override the default properties.\n */\nexport function RegionalRestApi(scope: Construct, apiGatewayProps?: api.RestApiProps,\n  logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup] {\n  // Configure log group for API Gateway AccessLogging\n  const logGroup = buildLogGroup(scope, 'ApiAccessLogGroup', logGroupProps);\n\n  const defaultProps = apiDefaults.DefaultRegionalRestApiProps(logGroup);\n  const [restApi, apiCWRole] = configureRestApi(scope, defaultProps, apiGatewayProps);\n  return [restApi, apiCWRole, logGroup ];\n}\n\nexport interface AddProxyMethodToApiResourceInputParams {\n    readonly service: string,\n    readonly action?: string,\n    readonly path?: string,\n    readonly apiResource: api.IResource,\n    readonly apiMethod: string,\n    readonly apiGatewayRole: IRole,\n    readonly requestTemplate: string,\n    readonly contentType?: string,\n    readonly requestValidator?: api.IRequestValidator,\n    readonly requestModel?: { [contentType: string]: api.IModel; },\n    readonly awsIntegrationProps?: api.AwsIntegrationProps | any,\n    readonly methodOptions?: api.MethodOptions\n}\n\nexport function addProxyMethodToApiResource(params: AddProxyMethodToApiResourceInputParams): api.Method {\n  let baseProps: api.AwsIntegrationProps = {\n    service: params.service,\n    integrationHttpMethod: \"POST\",\n    options: {\n      passthroughBehavior: api.PassthroughBehavior.NEVER,\n      credentialsRole: params.apiGatewayRole,\n      requestParameters: {\n        \"integration.request.header.Content-Type\": params.contentType ? params.contentType : \"'application/json'\"\n      },\n      requestTemplates: {\n        \"application/json\": params.requestTemplate\n      },\n      integrationResponses: [\n        {\n          statusCode: \"200\"\n        },\n        {\n          statusCode: \"500\",\n          responseTemplates: {\n            \"text/html\": \"Error\"\n          },\n          selectionPattern: \"500\"\n        }\n      ]\n    }\n  };\n\n  let extraProps;\n\n  if (params.action) {\n    extraProps = {\n      action: params.action\n    };\n  } else if (params.path) {\n    extraProps = {\n      path: params.path\n    };\n  } else {\n    throw Error('Either action or path is required');\n  }\n\n  // Setup the API Gateway AWS Integration\n  baseProps = Object.assign(baseProps, extraProps);\n  let apiGatewayIntegration;\n  if (params.awsIntegrationProps) {\n    const overridenProps = overrideProps(baseProps, params.awsIntegrationProps);\n    apiGatewayIntegration = new api.AwsIntegration(overridenProps);\n  } else {\n    apiGatewayIntegration = new api.AwsIntegration(baseProps);\n  }\n\n  const defaultMethodOptions = {\n    methodResponses: [\n      {\n        statusCode: \"200\",\n        responseParameters: {\n          \"method.response.header.Content-Type\": true\n        }\n      },\n      {\n        statusCode: \"500\",\n        responseParameters: {\n          \"method.response.header.Content-Type\": true\n        },\n      }\n    ],\n    requestValidator: params.requestValidator,\n    requestModels: params.requestModel\n  };\n\n  let apiMethod;\n  // Setup the API Gateway method\n  if (params.methodOptions) {\n    const overridenProps =  overrideProps(defaultMethodOptions, params.methodOptions);\n    apiMethod = params.apiResource.addMethod(params.apiMethod, apiGatewayIntegration, overridenProps);\n  } else {\n    apiMethod = params.apiResource.addMethod(params.apiMethod, apiGatewayIntegration, defaultMethodOptions);\n  }\n  return apiMethod;\n}"]}

package/lib/cloudfront-distribution-defaults.d.ts

@@ -15,5 +15,5 @@ import * as cloudfront from '@aws-cdk/aws-cloudfront';
 import * as mediastore from '@aws-cdk/aws-mediastore';
 import * as s3 from '@aws-cdk/aws-s3';
 export declare function DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint: api.RestApi, loggingBucket: s3.Bucket | undefined, setHttpSecurityHeaders: boolean, cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps;
-export declare function DefaultCloudFrontWebDistributionForS3Props(sourceBucket: s3.IBucket, loggingBucket: s3.Bucket | undefined, setHttpSecurityHeaders: boolean, cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps;
+export declare function DefaultCloudFrontWebDistributionForS3Props(sourceBucket: s3.IBucket, loggingBucket: s3.Bucket | undefined, setHttpSecurityHeaders: boolean, originPath?: string, cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps;
 export declare function DefaultCloudFrontDisributionForMediaStoreProps(mediastoreContainer: mediastore.CfnContainer, loggingBucket: s3.Bucket | undefined, originRequestPolicy: cloudfront.OriginRequestPolicy, setHttpSecurityHeaders: boolean, customHeaders?: Record<string, string>, cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps;

package/lib/cloudfront-distribution-defaults.js

@@ -33,10 +33,17 @@ function DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint, logging
     };
 }
 exports.DefaultCloudFrontWebDistributionForApiGatewayProps = DefaultCloudFrontWebDistributionForApiGatewayProps;
-function DefaultCloudFrontWebDistributionForS3Props(sourceBucket, loggingBucket, setHttpSecurityHeaders, cfFunction) {
+function DefaultCloudFrontWebDistributionForS3Props(sourceBucket, loggingBucket, setHttpSecurityHeaders, originPath, cfFunction) {
+    let origin;
+    if (originPath) {
+        origin = new origins.S3Origin(sourceBucket, { originPath });
+    }
+    else {
+        origin = new origins.S3Origin(sourceBucket);
+    }
     return {
         defaultBehavior: {
-            origin: new origins.S3Origin(sourceBucket),
+            origin,
             viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
             ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)
         },
@@ -76,4 +83,4 @@ function getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction) {
         ]
     } : {};
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-distribution-defaults.js","sourceRoot":"","sources":["cloudfront-distribution-defaults.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport * as api from '@aws-cdk/aws-apigateway';\nimport * as cloudfront from '@aws-cdk/aws-cloudfront';\nimport { FunctionEventType } from '@aws-cdk/aws-cloudfront';\nimport * as origins from '@aws-cdk/aws-cloudfront-origins';\nimport * as mediastore from '@aws-cdk/aws-mediastore';\nimport * as s3 from '@aws-cdk/aws-s3';\nimport * as cdk from '@aws-cdk/core';\n\nexport function DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint: api.RestApi,\n  loggingBucket: s3.Bucket | undefined,\n  setHttpSecurityHeaders: boolean,\n  cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps {\n\n  const apiEndPointUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split(\"://\", apiEndPoint.url));\n  const apiEndPointDomainName = cdk.Fn.select(0, cdk.Fn.split(\"/\", apiEndPointUrlWithoutProtocol));\n\n  return {\n    defaultBehavior: {\n      origin: new origins.HttpOrigin(apiEndPointDomainName, {\n        originPath: `/${apiEndPoint.deploymentStage.stageName}`\n      }),\n      ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction),\n      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS\n    },\n    enableLogging: true,\n    logBucket: loggingBucket,\n  };\n}\n\nexport function DefaultCloudFrontWebDistributionForS3Props(sourceBucket: s3.IBucket, loggingBucket: s3.Bucket | undefined,\n  setHttpSecurityHeaders: boolean,\n  cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps {\n\n  return {\n    defaultBehavior: {\n      origin: new origins.S3Origin(sourceBucket),\n      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)\n    },\n    enableLogging: true,\n    logBucket: loggingBucket,\n    defaultRootObject: 'index.html'\n  };\n}\n\nexport function DefaultCloudFrontDisributionForMediaStoreProps(mediastoreContainer: mediastore.CfnContainer,\n  loggingBucket: s3.Bucket | undefined,\n  originRequestPolicy: cloudfront.OriginRequestPolicy,\n  setHttpSecurityHeaders: boolean,\n  customHeaders?: Record<string, string>,\n  cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps {\n\n  const mediaStoreContainerUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split('://', mediastoreContainer.attrEndpoint));\n  const mediaStoreContainerDomainName = cdk.Fn.select(0, cdk.Fn.split('/', mediaStoreContainerUrlWithoutProtocol));\n\n  const httpOrigin: origins.HttpOrigin = customHeaders ?\n    new origins.HttpOrigin(mediaStoreContainerDomainName, { customHeaders }) :\n    new origins.HttpOrigin(mediaStoreContainerDomainName);\n\n  return {\n    defaultBehavior: {\n      origin: httpOrigin,\n      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      originRequestPolicy,\n      ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)\n    },\n    enableLogging: true,\n    logBucket: loggingBucket\n  };\n}\n\nfunction getFunctionAssociationsProp(setHttpSecurityHeaders: boolean, cfFunction: cloudfront.IFunction | undefined) {\n  return (setHttpSecurityHeaders && cfFunction) ? {\n    functionAssociations: [\n      {\n        eventType: FunctionEventType.VIEWER_RESPONSE,\n        function: cfFunction\n      }\n    ]\n  } : {};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-distribution-defaults.js","sourceRoot":"","sources":["cloudfront-distribution-defaults.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport * as api from '@aws-cdk/aws-apigateway';\nimport * as cloudfront from '@aws-cdk/aws-cloudfront';\nimport { FunctionEventType, IOrigin } from '@aws-cdk/aws-cloudfront';\nimport * as origins from '@aws-cdk/aws-cloudfront-origins';\nimport * as mediastore from '@aws-cdk/aws-mediastore';\nimport * as s3 from '@aws-cdk/aws-s3';\nimport * as cdk from '@aws-cdk/core';\n\nexport function DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint: api.RestApi,\n  loggingBucket: s3.Bucket | undefined,\n  setHttpSecurityHeaders: boolean,\n  cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps {\n\n  const apiEndPointUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split(\"://\", apiEndPoint.url));\n  const apiEndPointDomainName = cdk.Fn.select(0, cdk.Fn.split(\"/\", apiEndPointUrlWithoutProtocol));\n\n  return {\n    defaultBehavior: {\n      origin: new origins.HttpOrigin(apiEndPointDomainName, {\n        originPath: `/${apiEndPoint.deploymentStage.stageName}`\n      }),\n      ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction),\n      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS\n    },\n    enableLogging: true,\n    logBucket: loggingBucket,\n  };\n}\n\nexport function DefaultCloudFrontWebDistributionForS3Props(sourceBucket: s3.IBucket, loggingBucket: s3.Bucket | undefined,\n  setHttpSecurityHeaders: boolean,\n  originPath?: string,\n  cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps {\n\n  let origin: IOrigin;\n\n  if (originPath) {\n    origin = new origins.S3Origin(sourceBucket, { originPath });\n  } else {\n    origin = new origins.S3Origin(sourceBucket);\n  }\n\n  return {\n    defaultBehavior: {\n      origin,\n      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)\n    },\n    enableLogging: true,\n    logBucket: loggingBucket,\n    defaultRootObject: 'index.html'\n  };\n}\n\nexport function DefaultCloudFrontDisributionForMediaStoreProps(mediastoreContainer: mediastore.CfnContainer,\n  loggingBucket: s3.Bucket | undefined,\n  originRequestPolicy: cloudfront.OriginRequestPolicy,\n  setHttpSecurityHeaders: boolean,\n  customHeaders?: Record<string, string>,\n  cfFunction?: cloudfront.IFunction): cloudfront.DistributionProps {\n\n  const mediaStoreContainerUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split('://', mediastoreContainer.attrEndpoint));\n  const mediaStoreContainerDomainName = cdk.Fn.select(0, cdk.Fn.split('/', mediaStoreContainerUrlWithoutProtocol));\n\n  const httpOrigin: origins.HttpOrigin = customHeaders ?\n    new origins.HttpOrigin(mediaStoreContainerDomainName, { customHeaders }) :\n    new origins.HttpOrigin(mediaStoreContainerDomainName);\n\n  return {\n    defaultBehavior: {\n      origin: httpOrigin,\n      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      originRequestPolicy,\n      ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)\n    },\n    enableLogging: true,\n    logBucket: loggingBucket\n  };\n}\n\nfunction getFunctionAssociationsProp(setHttpSecurityHeaders: boolean, cfFunction: cloudfront.IFunction | undefined) {\n  return (setHttpSecurityHeaders && cfFunction) ? {\n    functionAssociations: [\n      {\n        eventType: FunctionEventType.VIEWER_RESPONSE,\n        function: cfFunction\n      }\n    ]\n  } : {};\n}\n"]}

package/lib/cloudfront-distribution-helper.d.ts

@@ -15,7 +15,7 @@ import * as s3 from '@aws-cdk/aws-s3';
 import * as api from '@aws-cdk/aws-apigateway';
 import * as mediastore from '@aws-cdk/aws-mediastore';
 import { Construct } from '@aws-cdk/core';
-export declare function CloudFrontDistributionForApiGateway(scope: Construct, apiEndPoint: api.RestApi, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean): [cloudfront.Distribution, cloudfront.Function?, s3.Bucket?];
-export declare function CloudFrontDistributionForS3(scope: Construct, sourceBucket: s3.IBucket, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean): [cloudfront.Distribution, cloudfront.Function?, s3.Bucket?];
-export declare function CloudFrontDistributionForMediaStore(scope: Construct, mediaStoreContainer: mediastore.CfnContainer, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean): [cloudfront.Distribution, s3.Bucket | undefined, cloudfront.OriginRequestPolicy, cloudfront.Function?];
+export declare function CloudFrontDistributionForApiGateway(scope: Construct, apiEndPoint: api.RestApi, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean, cloudFrontLoggingBucketProps?: s3.BucketProps): [cloudfront.Distribution, cloudfront.Function?, s3.Bucket?];
+export declare function CloudFrontDistributionForS3(scope: Construct, sourceBucket: s3.IBucket, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean, originPath?: string, cloudFrontLoggingBucketProps?: s3.BucketProps): [cloudfront.Distribution, cloudfront.Function?, s3.Bucket?];
+export declare function CloudFrontDistributionForMediaStore(scope: Construct, mediaStoreContainer: mediastore.CfnContainer, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean, cloudFrontLoggingBucketProps?: s3.BucketProps): [cloudfront.Distribution, s3.Bucket | undefined, cloudfront.OriginRequestPolicy, cloudfront.Function?];
 export declare function CloudFrontOriginAccessIdentity(scope: Construct, comment?: string): cloudfront.OriginAccessIdentity;