@aws-solutions-constructs/core 2.32.0 → 2.34.0

package/lib/alb-defaults.d.ts

@@ -11,4 +11,7 @@
  *  and limitations under the License.
  */
 import * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 export declare function DefaultListenerProps(loadBalancer: elb.ApplicationLoadBalancer): elb.ApplicationListenerProps;

package/lib/alb-defaults.js

@@ -13,7 +13,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultListenerProps = void 0;
+/*
+ *  The functions found here in the core library are for internal use and can be changed
+ *  or removed outside of a major release. We recommend against calling them directly from client code.
+ */
 const elb = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 function DefaultListenerProps(loadBalancer) {
     return {
         loadBalancer,
@@ -21,4 +28,4 @@ function DefaultListenerProps(loadBalancer) {
     };
 }
 exports.DefaultListenerProps = DefaultListenerProps;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxiLWRlZmF1bHRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYWxiLWRlZmF1bHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7R0FXRzs7O0FBRUgsOERBQThEO0FBRTlELFNBQWdCLG9CQUFvQixDQUFDLFlBQXlDO0lBQzVFLE9BQU87UUFDTCxZQUFZO1FBQ1osUUFBUSxFQUFFLEdBQUcsQ0FBQyxtQkFBbUIsQ0FBQyxLQUFLO0tBQ3hDLENBQUM7QUFDSixDQUFDO0FBTEQsb0RBS0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqICBDb3B5cmlnaHQgQW1hem9uLmNvbSwgSW5jLiBvciBpdHMgYWZmaWxpYXRlcy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiAgTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKS4gWW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZVxuICogIHdpdGggdGhlIExpY2Vuc2UuIEEgY29weSBvZiB0aGUgTGljZW5zZSBpcyBsb2NhdGVkIGF0XG4gKlxuICogICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiAgb3IgaW4gdGhlICdsaWNlbnNlJyBmaWxlIGFjY29tcGFueWluZyB0aGlzIGZpbGUuIFRoaXMgZmlsZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAnQVMgSVMnIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVNcbiAqICBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBleHByZXNzIG9yIGltcGxpZWQuIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9uc1xuICogIGFuZCBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgKiBhcyBlbGIgZnJvbSBcImF3cy1jZGstbGliL2F3cy1lbGFzdGljbG9hZGJhbGFuY2luZ3YyXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBEZWZhdWx0TGlzdGVuZXJQcm9wcyhsb2FkQmFsYW5jZXI6IGVsYi5BcHBsaWNhdGlvbkxvYWRCYWxhbmNlcik6IGVsYi5BcHBsaWNhdGlvbkxpc3RlbmVyUHJvcHMge1xuICByZXR1cm4ge1xuICAgIGxvYWRCYWxhbmNlcixcbiAgICBwcm90b2NvbDogZWxiLkFwcGxpY2F0aW9uUHJvdG9jb2wuSFRUUFMsXG4gIH07XG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxiLWRlZmF1bHRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYWxiLWRlZmF1bHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7R0FXRzs7O0FBRUg7OztHQUdHO0FBRUgsOERBQThEO0FBRTlEOztHQUVHO0FBQ0gsU0FBZ0Isb0JBQW9CLENBQUMsWUFBeUM7SUFDNUUsT0FBTztRQUNMLFlBQVk7UUFDWixRQUFRLEVBQUUsR0FBRyxDQUFDLG1CQUFtQixDQUFDLEtBQUs7S0FDeEMsQ0FBQztBQUNKLENBQUM7QUFMRCxvREFLQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogIENvcHlyaWdodCBBbWF6b24uY29tLCBJbmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqICBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpLiBZb3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlXG4gKiAgd2l0aCB0aGUgTGljZW5zZS4gQSBjb3B5IG9mIHRoZSBMaWNlbnNlIGlzIGxvY2F0ZWQgYXRcbiAqXG4gKiAgICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqICBvciBpbiB0aGUgJ2xpY2Vuc2UnIGZpbGUgYWNjb21wYW55aW5nIHRoaXMgZmlsZS4gVGhpcyBmaWxlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuICdBUyBJUycgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFU1xuICogIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGV4cHJlc3Mgb3IgaW1wbGllZC4gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zXG4gKiAgYW5kIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbi8qXG4gKiAgVGhlIGZ1bmN0aW9ucyBmb3VuZCBoZXJlIGluIHRoZSBjb3JlIGxpYnJhcnkgYXJlIGZvciBpbnRlcm5hbCB1c2UgYW5kIGNhbiBiZSBjaGFuZ2VkXG4gKiAgb3IgcmVtb3ZlZCBvdXRzaWRlIG9mIGEgbWFqb3IgcmVsZWFzZS4gV2UgcmVjb21tZW5kIGFnYWluc3QgY2FsbGluZyB0aGVtIGRpcmVjdGx5IGZyb20gY2xpZW50IGNvZGUuXG4gKi9cblxuaW1wb3J0ICogYXMgZWxiIGZyb20gXCJhd3MtY2RrLWxpYi9hd3MtZWxhc3RpY2xvYWRiYWxhbmNpbmd2MlwiO1xuXG4vKipcbiAqIEBpbnRlcm5hbCBUaGlzIGlzIGFuIGludGVybmFsIGNvcmUgZnVuY3Rpb24gYW5kIHNob3VsZCBub3QgYmUgY2FsbGVkIGRpcmVjdGx5IGJ5IFNvbHV0aW9ucyBDb25zdHJ1Y3RzIGNsaWVudHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBEZWZhdWx0TGlzdGVuZXJQcm9wcyhsb2FkQmFsYW5jZXI6IGVsYi5BcHBsaWNhdGlvbkxvYWRCYWxhbmNlcik6IGVsYi5BcHBsaWNhdGlvbkxpc3RlbmVyUHJvcHMge1xuICByZXR1cm4ge1xuICAgIGxvYWRCYWxhbmNlcixcbiAgICBwcm90b2NvbDogZWxiLkFwcGxpY2F0aW9uUHJvdG9jb2wuSFRUUFMsXG4gIH07XG59Il19

package/lib/alb-helper.d.ts

@@ -16,9 +16,38 @@ import * as ec2 from "aws-cdk-lib/aws-ec2";
 import * as s3 from "aws-cdk-lib/aws-s3";
 import * as ecs from "aws-cdk-lib/aws-ecs";
 import * as lambda from "aws-cdk-lib/aws-lambda";
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * Returns the correct ALB Load Balancer to use in this construct, either an existing
+ * one provided as an argument or create  new one otherwise.
+ */
 export declare function ObtainAlb(scope: Construct, id: string, vpc: ec2.IVpc, publicApi: boolean, existingLoadBalancerObj?: elb.ApplicationLoadBalancer, loadBalancerProps?: elb.ApplicationLoadBalancerProps | any, logAccessLogs?: boolean, loggingBucketProps?: s3.BucketProps): elb.ApplicationLoadBalancer;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 export declare function AddListener(scope: Construct, id: string, loadBalancer: elb.ApplicationLoadBalancer, listenerProps: elb.ApplicationListenerProps | any): elb.ApplicationListener;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * Creates a Target Group for Lambda functions and adds the
+ * provided functions as a target to that group. Then adds
+ * the new Target Group to the provided Listener.
+ */
 export declare function AddLambdaTarget(scope: Construct, id: string, currentListener: elb.ApplicationListener, lambdaFunction: lambda.IFunction, ruleProps?: elb.AddRuleProps, targetProps?: elb.ApplicationTargetGroupProps): elb.ApplicationTargetGroup;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 export declare function AddFargateTarget(scope: Construct, id: string, currentListener: elb.ApplicationListener, fargateService: ecs.FargateService, ruleProps?: elb.AddRuleProps, targetProps?: elb.ApplicationTargetGroupProps): elb.ApplicationTargetGroup;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * Looks for the listener associated with Target Groups
+ * If there is a single listener, this returns it whether it is HTTP or HTTPS
+ * If there are 2 listeners, it finds the HTTPS listener (we assume the HTTP listener redirects to HTTPS)
+ */
 export declare function GetActiveListener(listeners: elb.ApplicationListener[]): elb.ApplicationListener;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 export declare function CheckAlbProps(props: any): void;

package/lib/alb-helper.js

@@ -13,6 +13,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CheckAlbProps = exports.GetActiveListener = exports.AddFargateTarget = exports.AddLambdaTarget = exports.AddListener = exports.ObtainAlb = void 0;
+/*
+ *  The functions found here in the core library are for internal use and can be changed
+ *  or removed outside of a major release. We recommend against calling them directly from client code.
+ */
 const elb = require("aws-cdk-lib/aws-elasticloadbalancingv2");
 const aws_elasticloadbalancingv2_1 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
 const elbt = require("aws-cdk-lib/aws-elasticloadbalancingv2-targets");
@@ -20,8 +24,12 @@ 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.
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * 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, existingLoadBalancerObj, loadBalancerProps, logAccessLogs, loggingBucketProps) {
     let loadBalancer;
     if (existingLoadBalancerObj) {
@@ -39,6 +47,9 @@ function ObtainAlb(scope, id, vpc, publicApi, existingLoadBalancerObj, loadBalan
     return loadBalancer;
 }
 exports.ObtainAlb = ObtainAlb;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 function AddListener(scope, id, loadBalancer, listenerProps) {
     let consolidatedListenerProps;
     consolidatedListenerProps = utils_1.consolidateProps(alb_defaults_1.DefaultListenerProps(loadBalancer), listenerProps);
@@ -73,9 +84,13 @@ function AddListener(scope, id, loadBalancer, listenerProps) {
     return listener;
 }
 exports.AddListener = AddListener;
-// Creates a Target Group for Lambda functions and adds the
-// provided functions as a target to that group. Then adds
-// the new Target Group to the provided Listener.
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * Creates a Target Group for Lambda functions and adds the
+ * provided functions as a target to that group. Then adds
+ * the new Target Group to the provided Listener.
+ */
 function AddLambdaTarget(scope, id, currentListener, lambdaFunction, ruleProps, targetProps) {
     //  Create the target and assign it to a new target group
     const lambdaTarget = new elbt.LambdaTarget(lambdaFunction);
@@ -92,6 +107,9 @@ function AddLambdaTarget(scope, id, currentListener, lambdaFunction, ruleProps,
     return newTargetGroup;
 }
 exports.AddLambdaTarget = AddLambdaTarget;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 function AddFargateTarget(scope, id, currentListener, fargateService, ruleProps, targetProps) {
     if (targetProps?.protocol !== elb.ApplicationProtocol.HTTPS) {
         utils_1.printWarning('AWS recommends using HTTPS protocol for Target Groups in production applications');
@@ -105,9 +123,13 @@ function AddFargateTarget(scope, id, currentListener, fargateService, ruleProps,
     return newTargetGroup;
 }
 exports.AddFargateTarget = AddFargateTarget;
-// Looks for the listener associated with Target Groups
-// If there is a single listener, this returns it whether it is HTTP or HTTPS
-// If there are 2 listeners, it finds the HTTPS listener (we assume the HTTP listener redirects to HTTPS)
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * Looks for the listener associated with Target Groups
+ * If there is a single listener, this returns it whether it is HTTP or HTTPS
+ * If there are 2 listeners, it finds the HTTPS listener (we assume the HTTP listener redirects to HTTPS)
+ */
 function GetActiveListener(listeners) {
     let listener;
     if (listeners.length === 0) {
@@ -122,6 +144,9 @@ function GetActiveListener(listeners) {
     return listener;
 }
 exports.GetActiveListener = GetActiveListener;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
 function CheckAlbProps(props) {
     let errorMessages = '';
     let errorFound = false;
@@ -165,4 +190,4 @@ function CheckAlbProps(props) {
     }
 }
 exports.CheckAlbProps = CheckAlbProps;
-//# 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 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-lib/aws-elasticloadbalancingv2\";\nimport { Construct } from \"constructs\";\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport * as s3 from \"aws-cdk-lib/aws-s3\";\nimport * as ecs from \"aws-cdk-lib/aws-ecs\";\nimport * as lambda from \"aws-cdk-lib/aws-lambda\";\nimport { ApplicationProtocol, ListenerAction, } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport * as elbt from \"aws-cdk-lib/aws-elasticloadbalancingv2-targets\";\nimport { printWarning, consolidateProps } 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  existingLoadBalancerObj?: 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 (existingLoadBalancerObj) {\n    loadBalancer = existingLoadBalancerObj;\n  } else {\n    const consolidatedProps = consolidateProps({}, loadBalancerProps, { 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 = consolidateProps(DefaultLoggingBucketProps(), loggingBucketProps);\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  id: string,\n  loadBalancer: elb.ApplicationLoadBalancer,\n  listenerProps: elb.ApplicationListenerProps | any\n): elb.ApplicationListener {\n  let consolidatedListenerProps: elb.ApplicationListenerProps;\n\n  consolidatedListenerProps = consolidateProps(DefaultListenerProps(loadBalancer), listenerProps);\n\n  //  create the listener\n  const listener = new elb.ApplicationListener(\n    scope,\n    `${id}-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(`${id}-cert`, 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      `${id}-redirect`,\n      {\n        loadBalancer,\n        protocol: ApplicationProtocol.HTTP,\n        defaultAction: ListenerAction.redirect(opt),\n      }\n    );\n    loadBalancer.listeners.push(httpListener);\n  }\n\n  return listener;\n}\n\n// Creates a Target Group for Lambda functions and adds the\n// provided functions as a target to that group. Then adds\n// the new Target Group to the provided Listener.\nexport function AddLambdaTarget(\n  scope: Construct,\n  id: string,\n  currentListener: elb.ApplicationListener,\n  lambdaFunction: lambda.IFunction,\n  ruleProps?: elb.AddRuleProps,\n  targetProps?: elb.ApplicationTargetGroupProps,\n): elb.ApplicationTargetGroup  {\n\n  //  Create the target and assign it to a new target group\n  const lambdaTarget = new elbt.LambdaTarget(lambdaFunction);\n  const newTargetGroup = new elb.ApplicationTargetGroup(scope, `${id}-tg`, {\n    targets: [lambdaTarget],\n    targetGroupName: targetProps ? targetProps.targetGroupName : undefined,\n    healthCheck: targetProps ? targetProps.healthCheck : undefined\n  });\n\n  // The interface AddRuleProps includes conditions and priority, combine that\n  // with targetGroups and we can assemble AddApplicationTargetGroupProps\n  const consolidatedTargetProps = consolidateProps({}, ruleProps, { targetGroups: [newTargetGroup] });\n  currentListener.addTargetGroups(`${scope.node.id}-targets`, consolidatedTargetProps);\n\n  newTargetGroup.setAttribute('stickiness.enabled', undefined);\n  return newTargetGroup;\n}\n\nexport function AddFargateTarget(\n  scope: Construct,\n  id: string,\n  currentListener: elb.ApplicationListener,\n  fargateService: ecs.FargateService,\n  ruleProps?: elb.AddRuleProps,\n  targetProps?: elb.ApplicationTargetGroupProps,\n): elb.ApplicationTargetGroup  {\n\n  if (targetProps?.protocol !== elb.ApplicationProtocol.HTTPS) {\n    printWarning('AWS recommends using HTTPS protocol for Target Groups in production applications');\n  }\n\n  const newTargetGroup = new elb.ApplicationTargetGroup(scope, `${id}-tg`, targetProps);\n\n  // The interface AddRuleProps includes conditions and priority, combine that\n  // with targetGroups and we can assemble an AddApplicationTargetGroupProps object\n  const consolidatedTargetProps = consolidateProps({ targetGroups: [newTargetGroup] }, ruleProps);\n\n  currentListener.addTargetGroups(`${scope.node.id}-targets`, consolidatedTargetProps);\n  newTargetGroup.addTarget(fargateService);\n\n  return newTargetGroup;\n}\n\n// Looks for the listener associated with Target Groups\n// If there is a single listener, this returns it whether it is HTTP or HTTPS\n// If there are 2 listeners, it finds the HTTPS listener (we assume the HTTP listener redirects to HTTPS)\nexport function GetActiveListener(listeners: elb.ApplicationListener[]): elb.ApplicationListener {\n  let listener: elb.ApplicationListener;\n\n  if (listeners.length === 0 ) {\n    throw new Error(`There are no listeners in the ALB`);\n  }\n  if (listeners.length === 1 ) {\n    listener = listeners[0];\n  } else {\n    listener = listeners.find(i => (i.node.children[0] as elb.CfnListener).protocol === \"HTTPS\") as elb.ApplicationListener;\n  }\n  return listener;\n}\n\nexport function CheckAlbProps(props: any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (props.listenerProps?.certificateArns) {\n    errorMessages += \"certificateArns is deprecated. Please supply certificates using props.listenerProps.certificates\\n\";\n    errorFound = true;\n  }\n\n  if (\n    ((props.existingLoadBalancerObj &&\n      props.existingLoadBalancerObj.listeners.length === 0) ||\n      !props.existingLoadBalancerObj) &&\n    !props.listenerProps\n  ) {\n    errorMessages += \"When adding the first listener and target to a load balancer, listenerProps must be specified and include at least a certificate or protocol: HTTP\\n\";\n    errorFound = true;\n  }\n\n  if (\n    props.existingLoadBalancerObj &&\n    props.existingLoadBalancerObj.listeners.length > 0 &&\n    props.listenerProps\n  ) {\n    errorFound = true;\n    errorMessages += \"This load balancer already has a listener, listenerProps may not be specified\\n\";\n  }\n\n  if (\n    props.existingLoadBalancerObj &&\n    props.existingLoadBalancerObj.listeners.length > 0 &&\n    !props.ruleProps\n  ) {\n    errorFound = true;\n    errorMessages += \"When adding a second target to an existing listener, there must be rules provided\\n\";\n  }\n\n  // Check construct specific invalid inputs\n  if (props.existingLoadBalancerObj && !props.existingVpc) {\n    errorFound = true;\n    errorMessages += \"An existing ALB is already in a VPC, that VPC must be provided in props.existingVpc for the rest of the construct to use.\\n\";\n  }\n\n  if (props.loadBalancerProps?.vpc) {\n    errorFound = true;\n    errorMessages += 'Specify any existing VPC at the construct level, not within loadBalancerProps.\\n';\n  }\n\n  if (props.existingLoadBalancerObj) {\n    printWarning(\n      \"The public/private property of an existing ALB must match the props.publicApi setting provided.\"\n    );\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}"]}
+//# 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 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/*\n *  The functions found here in the core library are for internal use and can be changed\n *  or removed outside of a major release. We recommend against calling them directly from client code.\n */\n\nimport * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { Construct } from \"constructs\";\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport * as s3 from \"aws-cdk-lib/aws-s3\";\nimport * as ecs from \"aws-cdk-lib/aws-ecs\";\nimport * as lambda from \"aws-cdk-lib/aws-lambda\";\nimport { ApplicationProtocol, ListenerAction, } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport * as elbt from \"aws-cdk-lib/aws-elasticloadbalancingv2-targets\";\nimport { printWarning, consolidateProps } from \"./utils\";\nimport { DefaultListenerProps } from \"./alb-defaults\";\nimport { createAlbLoggingBucket } from \"./s3-bucket-helper\";\nimport { DefaultLoggingBucketProps } from \"./s3-bucket-defaults\";\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\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.\n */\nexport function ObtainAlb(\n  scope: Construct,\n  id: string,\n  vpc: ec2.IVpc,\n  publicApi: boolean,\n  existingLoadBalancerObj?: 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 (existingLoadBalancerObj) {\n    loadBalancer = existingLoadBalancerObj;\n  } else {\n    const consolidatedProps = consolidateProps({}, loadBalancerProps, { 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 = consolidateProps(DefaultLoggingBucketProps(), loggingBucketProps);\n      const loggingBucket = createAlbLoggingBucket(scope, id, consolidatedLoggingBucketProps);\n      loadBalancer.logAccessLogs(loggingBucket);\n    }\n  }\n  return loadBalancer;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function AddListener(\n  scope: Construct,\n  id: string,\n  loadBalancer: elb.ApplicationLoadBalancer,\n  listenerProps: elb.ApplicationListenerProps | any\n): elb.ApplicationListener {\n  let consolidatedListenerProps: elb.ApplicationListenerProps;\n\n  consolidatedListenerProps = consolidateProps(DefaultListenerProps(loadBalancer), listenerProps);\n\n  //  create the listener\n  const listener = new elb.ApplicationListener(\n    scope,\n    `${id}-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(`${id}-cert`, 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      `${id}-redirect`,\n      {\n        loadBalancer,\n        protocol: ApplicationProtocol.HTTP,\n        defaultAction: ListenerAction.redirect(opt),\n      }\n    );\n    loadBalancer.listeners.push(httpListener);\n  }\n\n  return listener;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Creates a Target Group for Lambda functions and adds the\n * provided functions as a target to that group. Then adds\n * the new Target Group to the provided Listener.\n */\nexport function AddLambdaTarget(\n  scope: Construct,\n  id: string,\n  currentListener: elb.ApplicationListener,\n  lambdaFunction: lambda.IFunction,\n  ruleProps?: elb.AddRuleProps,\n  targetProps?: elb.ApplicationTargetGroupProps,\n): elb.ApplicationTargetGroup  {\n\n  //  Create the target and assign it to a new target group\n  const lambdaTarget = new elbt.LambdaTarget(lambdaFunction);\n  const newTargetGroup = new elb.ApplicationTargetGroup(scope, `${id}-tg`, {\n    targets: [lambdaTarget],\n    targetGroupName: targetProps ? targetProps.targetGroupName : undefined,\n    healthCheck: targetProps ? targetProps.healthCheck : undefined\n  });\n\n  // The interface AddRuleProps includes conditions and priority, combine that\n  // with targetGroups and we can assemble AddApplicationTargetGroupProps\n  const consolidatedTargetProps = consolidateProps({}, ruleProps, { targetGroups: [newTargetGroup] });\n  currentListener.addTargetGroups(`${scope.node.id}-targets`, consolidatedTargetProps);\n\n  newTargetGroup.setAttribute('stickiness.enabled', undefined);\n  return newTargetGroup;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function AddFargateTarget(\n  scope: Construct,\n  id: string,\n  currentListener: elb.ApplicationListener,\n  fargateService: ecs.FargateService,\n  ruleProps?: elb.AddRuleProps,\n  targetProps?: elb.ApplicationTargetGroupProps,\n): elb.ApplicationTargetGroup  {\n\n  if (targetProps?.protocol !== elb.ApplicationProtocol.HTTPS) {\n    printWarning('AWS recommends using HTTPS protocol for Target Groups in production applications');\n  }\n\n  const newTargetGroup = new elb.ApplicationTargetGroup(scope, `${id}-tg`, targetProps);\n\n  // The interface AddRuleProps includes conditions and priority, combine that\n  // with targetGroups and we can assemble an AddApplicationTargetGroupProps object\n  const consolidatedTargetProps = consolidateProps({ targetGroups: [newTargetGroup] }, ruleProps);\n\n  currentListener.addTargetGroups(`${scope.node.id}-targets`, consolidatedTargetProps);\n  newTargetGroup.addTarget(fargateService);\n\n  return newTargetGroup;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Looks for the listener associated with Target Groups\n * If there is a single listener, this returns it whether it is HTTP or HTTPS\n * If there are 2 listeners, it finds the HTTPS listener (we assume the HTTP listener redirects to HTTPS)\n */\nexport function GetActiveListener(listeners: elb.ApplicationListener[]): elb.ApplicationListener {\n  let listener: elb.ApplicationListener;\n\n  if (listeners.length === 0 ) {\n    throw new Error(`There are no listeners in the ALB`);\n  }\n  if (listeners.length === 1 ) {\n    listener = listeners[0];\n  } else {\n    listener = listeners.find(i => (i.node.children[0] as elb.CfnListener).protocol === \"HTTPS\") as elb.ApplicationListener;\n  }\n  return listener;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function CheckAlbProps(props: any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (props.listenerProps?.certificateArns) {\n    errorMessages += \"certificateArns is deprecated. Please supply certificates using props.listenerProps.certificates\\n\";\n    errorFound = true;\n  }\n\n  if (\n    ((props.existingLoadBalancerObj &&\n      props.existingLoadBalancerObj.listeners.length === 0) ||\n      !props.existingLoadBalancerObj) &&\n    !props.listenerProps\n  ) {\n    errorMessages += \"When adding the first listener and target to a load balancer, listenerProps must be specified and include at least a certificate or protocol: HTTP\\n\";\n    errorFound = true;\n  }\n\n  if (\n    props.existingLoadBalancerObj &&\n    props.existingLoadBalancerObj.listeners.length > 0 &&\n    props.listenerProps\n  ) {\n    errorFound = true;\n    errorMessages += \"This load balancer already has a listener, listenerProps may not be specified\\n\";\n  }\n\n  if (\n    props.existingLoadBalancerObj &&\n    props.existingLoadBalancerObj.listeners.length > 0 &&\n    !props.ruleProps\n  ) {\n    errorFound = true;\n    errorMessages += \"When adding a second target to an existing listener, there must be rules provided\\n\";\n  }\n\n  // Check construct specific invalid inputs\n  if (props.existingLoadBalancerObj && !props.existingVpc) {\n    errorFound = true;\n    errorMessages += \"An existing ALB is already in a VPC, that VPC must be provided in props.existingVpc for the rest of the construct to use.\\n\";\n  }\n\n  if (props.loadBalancerProps?.vpc) {\n    errorFound = true;\n    errorMessages += 'Specify any existing VPC at the construct level, not within loadBalancerProps.\\n';\n  }\n\n  if (props.existingLoadBalancerObj) {\n    printWarning(\n      \"The public/private property of an existing ALB must match the props.publicApi setting provided.\"\n    );\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}"]}

package/lib/apigateway-defaults.d.ts

@@ -15,6 +15,8 @@ import { IntegrationResponse } from 'aws-cdk-lib/aws-apigateway';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import { LogGroup } from 'aws-cdk-lib/aws-logs';
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Edge/Global Lambda backed RestApi
  * @param scope - the construct to which the RestApi should be attached to.
  * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private
@@ -22,6 +24,8 @@ import { LogGroup } from 'aws-cdk-lib/aws-logs';
  */
 export declare function DefaultGlobalLambdaRestApiProps(_existingLambdaObj: lambda.Function, _logGroup: LogGroup): api.LambdaRestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Regional Lambda backed RestApi
  * @param scope - the construct to which the RestApi should be attached to.
  * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private
@@ -29,16 +33,22 @@ export declare function DefaultGlobalLambdaRestApiProps(_existingLambdaObj: lamb
  */
 export declare function DefaultRegionalLambdaRestApiProps(_existingLambdaObj: lambda.Function, _logGroup: LogGroup): api.LambdaRestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Edge/Global RestApi
  * @param _logGroup - CW Log group for Api Gateway access logging
  */
 export declare function DefaultGlobalRestApiProps(_logGroup: LogGroup): api.RestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Regional RestApi
  * @param _logGroup - CW Log group for Api Gateway access logging
  */
 export declare function DefaultRegionalRestApiProps(_logGroup: LogGroup): api.RestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * @returns The set of default integration responses for status codes 200 and 500.
  */
 export declare function DefaultIntegrationResponses(): IntegrationResponse[];

package/lib/apigateway-defaults.js

@@ -13,6 +13,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultIntegrationResponses = exports.DefaultRegionalRestApiProps = exports.DefaultGlobalRestApiProps = exports.DefaultRegionalLambdaRestApiProps = exports.DefaultGlobalLambdaRestApiProps = void 0;
+/*
+ *  The functions found here in the core library are for internal use and can be changed
+ *  or removed outside of a major release. We recommend against calling them directly from client code.
+ */
 const api = require("aws-cdk-lib/aws-apigateway");
 /**
  * Private function to configure an api.RestApiProps
@@ -40,6 +44,8 @@ function DefaultRestApiProps(_endpointType, _logGroup) {
     };
 }
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Edge/Global Lambda backed RestApi
  * @param scope - the construct to which the RestApi should be attached to.
  * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private
@@ -54,6 +60,8 @@ function DefaultGlobalLambdaRestApiProps(_existingLambdaObj, _logGroup) {
 }
 exports.DefaultGlobalLambdaRestApiProps = DefaultGlobalLambdaRestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Regional Lambda backed RestApi
  * @param scope - the construct to which the RestApi should be attached to.
  * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private
@@ -68,6 +76,8 @@ function DefaultRegionalLambdaRestApiProps(_existingLambdaObj, _logGroup) {
 }
 exports.DefaultRegionalLambdaRestApiProps = DefaultRegionalLambdaRestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Edge/Global RestApi
  * @param _logGroup - CW Log group for Api Gateway access logging
  */
@@ -76,6 +86,8 @@ function DefaultGlobalRestApiProps(_logGroup) {
 }
 exports.DefaultGlobalRestApiProps = DefaultGlobalRestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Provides the default set of properties for Regional RestApi
  * @param _logGroup - CW Log group for Api Gateway access logging
  */
@@ -84,6 +96,8 @@ function DefaultRegionalRestApiProps(_logGroup) {
 }
 exports.DefaultRegionalRestApiProps = DefaultRegionalRestApiProps;
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * @returns The set of default integration responses for status codes 200 and 500.
  */
 function DefaultIntegrationResponses() {
@@ -101,4 +115,4 @@ function DefaultIntegrationResponses() {
     ];
 }
 exports.DefaultIntegrationResponses = DefaultIntegrationResponses;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apigateway-defaults.js","sourceRoot":"","sources":["apigateway-defaults.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH;;;GAGG;AAEH,kDAAkD;AAKlD;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,aAAiC,EAAE,SAAmB;IACjF,OAAO;QACL,qBAAqB,EAAE;YACrB,KAAK,EAAE,aAAa;SACrB;QACD,cAAc,EAAE,KAAK;QACrB,uCAAuC;QACvC,aAAa,EAAE;YACb,oBAAoB,EAAE,IAAI,GAAG,CAAC,sBAAsB,CAAC,SAAS,CAAC;YAC/D,eAAe,EAAE,GAAG,CAAC,eAAe,CAAC,sBAAsB,EAAE;YAC7D,YAAY,EAAE,GAAG,CAAC,kBAAkB,CAAC,IAAI;YACzC,gBAAgB,EAAE,KAAK;YACvB,cAAc,EAAE,IAAI;SACrB;QACD,oBAAoB,EAAE;YACpB,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,CAAC,GAAG;SAC7C;KAEkB,CAAC;AACxB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,+BAA+B,CAAC,kBAAmC,EAAE,SAAmB;IACtG,MAAM,SAAS,GAAqB,mBAAmB,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;IAE5F,MAAM,UAAU,GAA2B;QACzC,OAAO,EAAE,kBAAkB;KAC5B,CAAC;IAEF,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAC9C,CAAC;AARD,0EAQC;AAED;;;;;;;GAOG;AACH,SAAgB,iCAAiC,CAAC,kBAAmC,EAAE,SAAmB;IACxG,MAAM,SAAS,GAAqB,mBAAmB,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC;IAEhG,MAAM,UAAU,GAA2B;QACzC,OAAO,EAAE,kBAAkB;KAC5B,CAAC;IAEF,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAC9C,CAAC;AARD,8EAQC;AAED;;;;;GAKG;AACH,SAAgB,yBAAyB,CAAC,SAAmB;IAC3D,OAAO,mBAAmB,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;AACjE,CAAC;AAFD,8DAEC;AAED;;;;;GAKG;AACH,SAAgB,2BAA2B,CAAC,SAAmB;IAC7D,OAAO,mBAAmB,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC;AACrE,CAAC;AAFD,kEAEC;AAED;;;;GAIG;AACH,SAAgB,2BAA2B;IACzC,OAAO;QACL;YACE,UAAU,EAAE,KAAK;SAClB;QACD;YACE,UAAU,EAAE,KAAK;YACjB,iBAAiB,EAAE;gBACjB,WAAW,EAAE,OAAO;aACrB;YACD,gBAAgB,EAAE,KAAK;SACxB;KACF,CAAC;AACJ,CAAC;AAbD,kEAaC","sourcesContent":["/**\n *  Copyright 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/*\n *  The functions found here in the core library are for internal use and can be changed\n *  or removed outside of a major release. We recommend against calling them directly from client code.\n */\n\nimport * as api from 'aws-cdk-lib/aws-apigateway';\nimport { IntegrationResponse } from 'aws-cdk-lib/aws-apigateway';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { LogGroup } from 'aws-cdk-lib/aws-logs';\n\n/**\n * Private function to configure an api.RestApiProps\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private\n * @param _logGroup - CW Log group for Api Gateway access logging\n */\nfunction DefaultRestApiProps(_endpointType: api.EndpointType[], _logGroup: LogGroup): api.RestApiProps {\n  return {\n    endpointConfiguration: {\n      types: _endpointType\n    },\n    cloudWatchRole: false,\n    // Configure API Gateway Access logging\n    deployOptions: {\n      accessLogDestination: new api.LogGroupLogDestination(_logGroup),\n      accessLogFormat: api.AccessLogFormat.jsonWithStandardFields(),\n      loggingLevel: api.MethodLoggingLevel.INFO,\n      dataTraceEnabled: false,\n      tracingEnabled: true\n    },\n    defaultMethodOptions: {\n      authorizationType: api.AuthorizationType.IAM\n    }\n\n  } as api.RestApiProps;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Provides the default set of properties for Edge/Global Lambda backed RestApi\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private\n * @param _logGroup - CW Log group for Api Gateway access logging\n */\nexport function DefaultGlobalLambdaRestApiProps(_existingLambdaObj: lambda.Function, _logGroup: LogGroup): api.LambdaRestApiProps {\n  const baseProps: api.RestApiProps = DefaultRestApiProps([api.EndpointType.EDGE], _logGroup);\n\n  const extraProps: api.LambdaRestApiProps = {\n    handler: _existingLambdaObj,\n  };\n\n  return Object.assign(baseProps, extraProps);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Provides the default set of properties for Regional Lambda backed RestApi\n * @param scope - the construct to which the RestApi should be attached to.\n * @param _endpointType - endpoint type for Api Gateway e.g. Regional, Global, Private\n * @param _logGroup - CW Log group for Api Gateway access logging\n */\nexport function DefaultRegionalLambdaRestApiProps(_existingLambdaObj: lambda.Function, _logGroup: LogGroup): api.LambdaRestApiProps {\n  const baseProps: api.RestApiProps = DefaultRestApiProps([api.EndpointType.REGIONAL], _logGroup);\n\n  const extraProps: api.LambdaRestApiProps = {\n    handler: _existingLambdaObj,\n  };\n\n  return Object.assign(baseProps, extraProps);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Provides the default set of properties for Edge/Global RestApi\n * @param _logGroup - CW Log group for Api Gateway access logging\n */\nexport function DefaultGlobalRestApiProps(_logGroup: LogGroup) {\n  return DefaultRestApiProps([api.EndpointType.EDGE], _logGroup);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Provides the default set of properties for Regional RestApi\n * @param _logGroup - CW Log group for Api Gateway access logging\n */\nexport function DefaultRegionalRestApiProps(_logGroup: LogGroup) {\n  return DefaultRestApiProps([api.EndpointType.REGIONAL], _logGroup);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * @returns The set of default integration responses for status codes 200 and 500.\n */\nexport function DefaultIntegrationResponses(): IntegrationResponse[] {\n  return [\n    {\n      statusCode: \"200\"\n    },\n    {\n      statusCode: \"500\",\n      responseTemplates: {\n        \"text/html\": \"Error\"\n      },\n      selectionPattern: \"500\"\n    }\n  ];\n}"]}

package/lib/apigateway-helper.d.ts

@@ -13,41 +13,69 @@
 import * as logs from 'aws-cdk-lib/aws-logs';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as cdk from 'aws-cdk-lib';
-import * as api from 'aws-cdk-lib/aws-apigateway';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import { IRole } from 'aws-cdk-lib/aws-iam';
 import { Construct } from 'constructs';
+export interface GlobalLambdaRestApiResponse {
+    readonly api: apigateway.RestApi;
+    readonly role?: iam.Role;
+    readonly group: logs.LogGroup;
+}
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * Builds and returns a global 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 GlobalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function, apiGatewayProps?: api.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): [api.RestApi, iam.Role | undefined, logs.LogGroup];
+export declare function GlobalLambdaRestApi(scope: Construct, _existingLambdaObj: lambda.Function, apiGatewayProps?: apigateway.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): GlobalLambdaRestApiResponse;
+export interface RegionalLambdaRestApiResponse {
+    readonly api: apigateway.RestApi;
+    readonly role?: iam.Role;
+    readonly group: logs.LogGroup;
+}
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * 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 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 | undefined, logs.LogGroup];
+export declare function RegionalLambdaRestApi(scope: Construct, existingLambdaObj: lambda.Function, apiGatewayProps?: apigateway.LambdaRestApiProps, logGroupProps?: logs.LogGroupProps): RegionalLambdaRestApiResponse;
+export interface GlobalRestApiResponse {
+    readonly api: apigateway.RestApi;
+    readonly role?: iam.Role;
+    readonly logGroup: logs.LogGroup;
+}
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * 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 | undefined, logs.LogGroup];
+export declare function GlobalRestApi(scope: Construct, apiGatewayProps?: apigateway.RestApiProps, logGroupProps?: logs.LogGroupProps): GlobalRestApiResponse;
+export interface RegionalRestApiResponse {
+    readonly api: apigateway.RestApi;
+    readonly role?: iam.Role;
+    readonly logGroup: logs.LogGroup;
+}
 /**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
  * 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 | undefined, logs.LogGroup];
+export declare function RegionalRestApi(scope: Construct, apiGatewayProps?: apigateway.RestApiProps, logGroupProps?: logs.LogGroupProps): RegionalRestApiResponse;
 export interface AddProxyMethodToApiResourceInputParams {
     readonly service: string;
     readonly action?: string;
     readonly path?: string;
-    readonly apiResource: api.IResource;
+    readonly apiResource: apigateway.IResource;
     readonly apiMethod: string;
     readonly apiGatewayRole: IRole;
     readonly requestTemplate: string;
@@ -56,11 +84,14 @@ export interface AddProxyMethodToApiResourceInputParams {
     };
     readonly integrationResponses?: cdk.aws_apigateway.IntegrationResponse[];
     readonly contentType?: string;
-    readonly requestValidator?: api.IRequestValidator;
+    readonly requestValidator?: apigateway.IRequestValidator;
     readonly requestModel?: {
-        [contentType: string]: api.IModel;
+        [contentType: string]: apigateway.IModel;
     };
-    readonly awsIntegrationProps?: api.AwsIntegrationProps | any;
-    readonly methodOptions?: api.MethodOptions;
+    readonly awsIntegrationProps?: apigateway.AwsIntegrationProps | any;
+    readonly methodOptions?: apigateway.MethodOptions;
 }
-export declare function addProxyMethodToApiResource(params: AddProxyMethodToApiResourceInputParams): api.Method;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function addProxyMethodToApiResource(params: AddProxyMethodToApiResourceInputParams): apigateway.Method;