@aws-solutions-constructs/core 2.41.0 → 2.43.0

package/lib/kendra-defaults.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ *  Copyright 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.DefaultKendraIndexProps = void 0;
+const utils_1 = require("./utils");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function DefaultKendraIndexProps(id, roleArn) {
+    return {
+        name: utils_1.generatePhysicalName("", ["KendraIndex", id], 1000),
+        roleArn,
+        edition: 'DEVELOPER_EDITION',
+    };
+}
+exports.DefaultKendraIndexProps = DefaultKendraIndexProps;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2VuZHJhLWRlZmF1bHRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsia2VuZHJhLWRlZmF1bHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7R0FXRzs7O0FBR0gsbUNBQStDO0FBRS9DOztHQUVHO0FBQ0gsU0FBZ0IsdUJBQXVCLENBQUMsRUFBVSxFQUFFLE9BQWdCO0lBQ2xFLE9BQU87UUFDTCxJQUFJLEVBQUUsNEJBQW9CLENBQUMsRUFBRSxFQUFFLENBQUMsYUFBYSxFQUFFLEVBQUUsQ0FBQyxFQUFFLElBQUksQ0FBQztRQUN6RCxPQUFPO1FBQ1AsT0FBTyxFQUFFLG1CQUFtQjtLQUNMLENBQUM7QUFDNUIsQ0FBQztBQU5ELDBEQU1DIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiAgQ29weXJpZ2h0IEFtYXpvbi5jb20sIEluYy4gb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIikuIFlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2VcbiAqICB3aXRoIHRoZSBMaWNlbnNlLiBBIGNvcHkgb2YgdGhlIExpY2Vuc2UgaXMgbG9jYXRlZCBhdFxuICpcbiAqICAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogIG9yIGluIHRoZSAnbGljZW5zZScgZmlsZSBhY2NvbXBhbnlpbmcgdGhpcyBmaWxlLiBUaGlzIGZpbGUgaXMgZGlzdHJpYnV0ZWQgb24gYW4gJ0FTIElTJyBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTXG4gKiAgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZXhwcmVzcyBvciBpbXBsaWVkLiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnNcbiAqICBhbmQgbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0ICogYXMga2VuZHJhIGZyb20gJ2F3cy1jZGstbGliL2F3cy1rZW5kcmEnO1xuaW1wb3J0IHsgZ2VuZXJhdGVQaHlzaWNhbE5hbWUgfSBmcm9tIFwiLi91dGlsc1wiO1xuXG4vKipcbiAqIEBpbnRlcm5hbCBUaGlzIGlzIGFuIGludGVybmFsIGNvcmUgZnVuY3Rpb24gYW5kIHNob3VsZCBub3QgYmUgY2FsbGVkIGRpcmVjdGx5IGJ5IFNvbHV0aW9ucyBDb25zdHJ1Y3RzIGNsaWVudHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBEZWZhdWx0S2VuZHJhSW5kZXhQcm9wcyhpZDogc3RyaW5nLCByb2xlQXJuPzogc3RyaW5nKToga2VuZHJhLkNmbkluZGV4UHJvcHMge1xuICByZXR1cm4ge1xuICAgIG5hbWU6IGdlbmVyYXRlUGh5c2ljYWxOYW1lKFwiXCIsIFtcIktlbmRyYUluZGV4XCIsIGlkXSwgMTAwMCksXG4gICAgcm9sZUFybixcbiAgICBlZGl0aW9uOiAnREVWRUxPUEVSX0VESVRJT04nLFxuICB9IGFzIGtlbmRyYS5DZm5JbmRleFByb3BzO1xufVxuIl19

package/lib/kendra-helper.d.ts

@@ -0,0 +1,36 @@
+/**
+ *  Copyright 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 kendra from 'aws-cdk-lib/aws-kendra';
+import { Construct } from 'constructs';
+export interface BuildKendraIndexProps {
+    readonly kendraIndexProps?: kendra.CfnIndexProps | any;
+    /**
+     * Existing instance of Kendra Index object, Providing both this and kendraIndexProps will cause an error.
+     *
+     * @default - None
+     */
+    readonly existingIndexObj?: kendra.CfnIndex;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildKendraIndex(scope: Construct, id: string, props: BuildKendraIndexProps): kendra.CfnIndex;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function AddMultipleKendraDataSources(scope: Construct, id: string, kendraIndex: kendra.CfnIndex, clientDataSourceProps: Array<Partial<kendra.CfnDataSourceProps>>): kendra.CfnDataSource[];
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function AddKendraDataSource(scope: Construct, id: string, index: kendra.CfnIndex, clientDataSourceProps: kendra.CfnDataSourceProps | any): kendra.CfnDataSource;
+export declare function normalizeKendraPermissions(rawPermissions: string[]): string[];

package/lib/kendra-helper.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ *  Copyright 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.normalizeKendraPermissions = exports.AddKendraDataSource = exports.AddMultipleKendraDataSources = exports.buildKendraIndex = 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 kendra = require("aws-cdk-lib/aws-kendra");
+const iam = require("aws-cdk-lib/aws-iam");
+const utils_1 = require("./utils");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const kendra_defaults_1 = require("./kendra-defaults");
+const utils_2 = require("./utils");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildKendraIndex(scope, id, props) {
+    // Conditional lambda function creation
+    if (props.existingIndexObj) {
+        // The client provided an Index, so we'll do nothing and return it to them
+        return props.existingIndexObj;
+    }
+    else {
+        let indexRoleArn = "";
+        // If the client provided a role, then don't bother creating a new one that we don't need
+        if (!props.kendraIndexProps?.roleArn) {
+            indexRoleArn = CreateKendraIndexLoggingRole(scope, id);
+        }
+        const defaultIndexProperties = kendra_defaults_1.DefaultKendraIndexProps(id, indexRoleArn);
+        const consolidatedIndexProperties = utils_1.consolidateProps(defaultIndexProperties, props.kendraIndexProps);
+        const newIndex = new kendra.CfnIndex(scope, `kendra-index-${id}`, consolidatedIndexProperties);
+        utils_1.addCfnSuppressRules(newIndex, [{
+                id: "W80",
+                reason: "We consulted the Kendra TFC and they confirmed the default encryption is sufficient for general use cases"
+            }]);
+        return newIndex;
+    }
+}
+exports.buildKendraIndex = buildKendraIndex;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function AddMultipleKendraDataSources(scope, id, kendraIndex, clientDataSourceProps) {
+    const returnDataSources = [];
+    clientDataSourceProps.forEach((props, index) => {
+        returnDataSources.push(AddKendraDataSource(scope, `${id}${index}`, kendraIndex, props));
+    });
+    return returnDataSources;
+}
+exports.AddMultipleKendraDataSources = AddMultipleKendraDataSources;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function AddKendraDataSource(scope, id, index, clientDataSourceProps) {
+    if (clientDataSourceProps.type === 'S3') {
+        return CreateS3DataSource(scope, index, id, clientDataSourceProps);
+    }
+    else {
+        if (clientDataSourceProps.indexId) {
+            throw new Error('Invalid DataSource prop specified - Construct must set the indexId prop');
+        }
+        return new kendra.CfnDataSource(scope, `kendra-data-source-${id}`, {
+            ...clientDataSourceProps,
+            indexId: index.attrId
+        });
+    }
+}
+exports.AddKendraDataSource = AddKendraDataSource;
+function CreateS3DataSource(scope, targetIndex, id, clientProps) {
+    // We go through some hoops here to extract the various inputs, because we need to narrow
+    // the type to remove the union with IResolvable
+    const dataSourceConfig = clientProps.dataSourceConfiguration;
+    if (!dataSourceConfig) {
+        throw new Error('Error - an S3 Kendra DataSource requires an DataSourceCofiguration prop');
+    }
+    const s3DataSourceConfig = dataSourceConfig.s3Configuration;
+    if (!s3DataSourceConfig) {
+        throw new Error('Error - an S3 Kendra DataSource requires an DataSourceCofiguration.S3Configuration prop');
+    }
+    // No Bucket name is an error
+    if (!s3DataSourceConfig.bucketName) {
+        throw new Error('Error - an S3 Kendra DataSource requires the DataSourceCofiguration.S3Configuration.bucketName prop');
+    }
+    // If there's no role, make a role and put it into defaultProps
+    // Put bucket name in default props
+    let defaultProps = {
+        indexId: targetIndex.ref,
+        name: utils_2.generatePhysicalName('', ['s3-datasource', id], 1000),
+        type: 'S3'
+    };
+    // Return consolidated default and user props
+    if (!clientProps.roleArn) {
+        const s3CrawlPolicy = new iam.PolicyDocument({
+            statements: [
+                new iam.PolicyStatement({
+                    actions: [
+                        "s3:GetObject"
+                    ],
+                    resources: [
+                        `arn:aws:s3:::${s3DataSourceConfig.bucketName}/*`
+                    ],
+                    effect: iam.Effect.ALLOW
+                }),
+                new iam.PolicyStatement({
+                    actions: [
+                        "s3:ListBucket"
+                    ],
+                    resources: [
+                        `arn:aws:s3:::${s3DataSourceConfig.bucketName}`
+                    ],
+                    effect: iam.Effect.ALLOW
+                }),
+                new iam.PolicyStatement({
+                    effect: iam.Effect.ALLOW,
+                    actions: [
+                        "kendra:BatchPutDocument",
+                        "kendra:BatchDeleteDocument"
+                    ],
+                    resources: [
+                        targetIndex.attrArn
+                    ]
+                }),
+            ]
+        });
+        const dataSourceRole = new iam.Role(scope, `data-source-role-${id}`, {
+            assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),
+            description: 'Policy for Kendra S3 Data Source',
+            inlinePolicies: {
+                s3CrawlPolicy,
+            },
+        });
+        defaultProps = utils_2.overrideProps(defaultProps, { roleArn: dataSourceRole.roleArn });
+    }
+    const consolidatedProps = utils_1.consolidateProps(defaultProps, clientProps);
+    return new kendra.CfnDataSource(scope, `data-source-${id}`, consolidatedProps);
+}
+function CreateKendraIndexLoggingRole(scope, id) {
+    const allowKendraToLogPolicy = new iam.PolicyDocument({
+        statements: [
+            new iam.PolicyStatement({
+                resources: ['*'],
+                actions: [
+                    "cloudwatch:PutMetricData"
+                ],
+                effect: iam.Effect.ALLOW,
+                conditions: {
+                    StringEquals: {
+                        "cloudwatch:namespace": "AWS/Kendra"
+                    }
+                }
+            }),
+            new iam.PolicyStatement({
+                resources: [`arn:aws:logs:${aws_cdk_lib_1.Aws.REGION}:${aws_cdk_lib_1.Aws.ACCOUNT_ID}:log-group:/aws/kendra/*`],
+                actions: [
+                    "logs:CreateLogGroup"
+                ],
+                effect: iam.Effect.ALLOW,
+            }),
+            new iam.PolicyStatement({
+                resources: [`arn:${aws_cdk_lib_1.Aws.PARTITION}:logs:${aws_cdk_lib_1.Aws.REGION}:${aws_cdk_lib_1.Aws.ACCOUNT_ID}:log-group:/aws/kendra/*`],
+                actions: [
+                    "logs:DescribeLogGroups"
+                ],
+                effect: iam.Effect.ALLOW,
+            }),
+            new iam.PolicyStatement({
+                resources: [`arn:${aws_cdk_lib_1.Aws.PARTITION}:logs:${aws_cdk_lib_1.Aws.REGION}:${aws_cdk_lib_1.Aws.ACCOUNT_ID}:log-group:/aws/kendra/*:log-stream:*`],
+                actions: [
+                    'logs:CreateLogStream',
+                    'logs:PutLogEvents',
+                    'logs:DescribeLogStream',
+                ],
+                effect: iam.Effect.ALLOW,
+            }),
+        ],
+    });
+    const indexRole = new iam.Role(scope, `kendra-index-role-${id}`, {
+        assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),
+        description: 'Allow Kendra index to write CloudWatch Logs',
+        inlinePolicies: {
+            AllowLogging: allowKendraToLogPolicy,
+        },
+    });
+    utils_1.addCfnSuppressRules(indexRole, [{
+            id: "W11",
+            reason: "PutMetricData does not allow resource specification, " +
+                "scope is narrowed by the namespace condition. " +
+                "https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatch.html"
+        }]);
+    return indexRole.roleArn;
+}
+// @summary Confirm each entry is a correct value, uppercase each entry
+function normalizeKendraPermissions(rawPermissions) {
+    const validPermissions = ["READ", "SUBMITFEEDBACK", "WRITE"];
+    const result = rawPermissions.map((s) => {
+        const upperCaseValue = s.toUpperCase();
+        if (!validPermissions.includes(upperCaseValue)) {
+            throw new Error(`Invalid indexPermission value - valid values are "READ", "SUBMITFEEDBACK" and "WRITE"`);
+        }
+        return upperCaseValue;
+    });
+    return result;
+}
+exports.normalizeKendraPermissions = normalizeKendraPermissions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kendra-helper.js","sourceRoot":"","sources":["kendra-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 kendra from 'aws-cdk-lib/aws-kendra';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { addCfnSuppressRules, consolidateProps } from \"./utils\";\nimport { Aws } from 'aws-cdk-lib';\n\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\nimport { DefaultKendraIndexProps } from './kendra-defaults';\nimport { generatePhysicalName, overrideProps } from \"./utils\";\n\nexport interface BuildKendraIndexProps {\n  readonly kendraIndexProps?: kendra.CfnIndexProps | any;\n  /**\n   * Existing instance of Kendra Index object, Providing both this and kendraIndexProps will cause an error.\n   *\n   * @default - None\n   */\n  readonly existingIndexObj?: kendra.CfnIndex;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildKendraIndex(scope: Construct, id: string, props: BuildKendraIndexProps): kendra.CfnIndex {\n  // Conditional lambda function creation\n  if (props.existingIndexObj) {\n    // The client provided an Index, so we'll do nothing and return it to them\n    return props.existingIndexObj;\n  } else {\n\n    let indexRoleArn: string = \"\";\n\n    // If the client provided a role, then don't bother creating a new one that we don't need\n    if (!props.kendraIndexProps?.roleArn) {\n      indexRoleArn = CreateKendraIndexLoggingRole(scope, id);\n    }\n    const defaultIndexProperties = DefaultKendraIndexProps(id, indexRoleArn);\n\n    const consolidatedIndexProperties = consolidateProps(defaultIndexProperties, props.kendraIndexProps);\n    const newIndex = new kendra.CfnIndex(scope, `kendra-index-${id}`, consolidatedIndexProperties);\n    addCfnSuppressRules(newIndex, [{\n      id: \"W80\",\n      reason: \"We consulted the Kendra TFC and they confirmed the default encryption is sufficient for general use cases\"\n    }]);\n\n    return newIndex;\n  }\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function AddMultipleKendraDataSources(scope: Construct,\n  id: string,\n  kendraIndex: kendra.CfnIndex,\n  clientDataSourceProps: Array<Partial<kendra.CfnDataSourceProps>>): kendra.CfnDataSource[] {\n\n  const returnDataSources: kendra.CfnDataSource[] = [];\n  clientDataSourceProps.forEach((props, index) => {\n    returnDataSources.push(AddKendraDataSource(scope, `${id}${index}`, kendraIndex, props));\n  });\n  return returnDataSources;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function AddKendraDataSource(scope: Construct,\n  id: string, index: kendra.CfnIndex,\n  clientDataSourceProps: kendra.CfnDataSourceProps | any): kendra.CfnDataSource {\n\n  if  (clientDataSourceProps.type === 'S3') {\n    return CreateS3DataSource(scope, index, id, clientDataSourceProps);\n  } else {\n    if (clientDataSourceProps.indexId) {\n      throw new Error('Invalid DataSource prop specified - Construct must set the indexId prop');\n    }\n    return new kendra.CfnDataSource(scope, `kendra-data-source-${id}`, {\n      ...clientDataSourceProps,\n      indexId: index.attrId\n    });\n  }\n}\n\nfunction CreateS3DataSource(scope: Construct,\n  targetIndex: kendra.CfnIndex,\n  id: string,\n  clientProps: Partial<kendra.CfnDataSourceProps>): kendra.CfnDataSource {\n\n  // We go through some hoops here to extract the various inputs, because we need to narrow\n  // the type to remove the union with IResolvable\n  const dataSourceConfig = clientProps.dataSourceConfiguration as kendra.CfnDataSource.DataSourceConfigurationProperty;\n  if (!dataSourceConfig) {\n    throw new Error('Error - an S3 Kendra DataSource requires an DataSourceCofiguration prop');\n  }\n\n  const s3DataSourceConfig = dataSourceConfig.s3Configuration as kendra.CfnDataSource.S3DataSourceConfigurationProperty;\n\n  if (!s3DataSourceConfig) {\n    throw new Error('Error - an S3 Kendra DataSource requires an DataSourceCofiguration.S3Configuration prop');\n  }\n\n  // No Bucket name is an error\n  if (!s3DataSourceConfig.bucketName) {\n    throw new Error('Error - an S3 Kendra DataSource requires the DataSourceCofiguration.S3Configuration.bucketName prop');\n  }\n\n  // If there's no role, make a role and put it into defaultProps\n  // Put bucket name in default props\n  let defaultProps: kendra.CfnDataSourceProps = {\n    indexId: targetIndex.ref,\n    name: generatePhysicalName('', ['s3-datasource', id], 1000),\n    type: 'S3'\n  };\n\n  // Return consolidated default and user props\n  if (!clientProps.roleArn) {\n    const s3CrawlPolicy = new iam.PolicyDocument({\n      statements: [\n        new iam.PolicyStatement({\n          actions: [\n            \"s3:GetObject\"\n          ],\n          resources: [\n            `arn:aws:s3:::${s3DataSourceConfig.bucketName}/*`\n          ],\n          effect: iam.Effect.ALLOW\n        }),\n        new iam.PolicyStatement({\n          actions: [\n            \"s3:ListBucket\"\n          ],\n          resources: [\n            `arn:aws:s3:::${s3DataSourceConfig.bucketName}`\n          ],\n          effect: iam.Effect.ALLOW\n        }),\n        new iam.PolicyStatement({\n          effect: iam.Effect.ALLOW,\n          actions: [\n            \"kendra:BatchPutDocument\",\n            \"kendra:BatchDeleteDocument\"\n          ],\n          resources: [\n            targetIndex.attrArn\n          ]\n        }),\n      ]\n    });\n\n    const dataSourceRole: iam.Role = new iam.Role(scope, `data-source-role-${id}`, {\n      assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),\n      description: 'Policy for Kendra S3 Data Source',\n      inlinePolicies: {\n        s3CrawlPolicy,\n      },\n    });\n    defaultProps = overrideProps(defaultProps, { roleArn: dataSourceRole.roleArn });\n  }\n\n  const consolidatedProps: kendra.CfnDataSourceProps = consolidateProps(defaultProps, clientProps);\n\n  return new kendra.CfnDataSource(scope, `data-source-${id}`, consolidatedProps);\n\n}\n\nfunction CreateKendraIndexLoggingRole(scope: Construct, id: string): string {\n  const allowKendraToLogPolicy = new iam.PolicyDocument({\n    statements: [\n      new iam.PolicyStatement({\n        resources: ['*'],\n        actions: [\n          \"cloudwatch:PutMetricData\"\n        ],\n        effect: iam.Effect.ALLOW,\n        conditions: {\n          StringEquals: {\n            \"cloudwatch:namespace\": \"AWS/Kendra\"\n          }\n        }\n      }),\n      new iam.PolicyStatement({\n        resources: [`arn:aws:logs:${Aws.REGION}:${Aws.ACCOUNT_ID}:log-group:/aws/kendra/*`],\n        actions: [\n          \"logs:CreateLogGroup\"\n        ],\n        effect: iam.Effect.ALLOW,\n      }),\n      new iam.PolicyStatement({\n        resources: [`arn:${Aws.PARTITION}:logs:${Aws.REGION}:${Aws.ACCOUNT_ID}:log-group:/aws/kendra/*`],\n        actions: [\n          \"logs:DescribeLogGroups\"\n        ],\n        effect: iam.Effect.ALLOW,\n      }),\n      new iam.PolicyStatement({\n        resources: [`arn:${Aws.PARTITION}:logs:${Aws.REGION}:${Aws.ACCOUNT_ID}:log-group:/aws/kendra/*:log-stream:*`],\n        actions: [\n          'logs:CreateLogStream',\n          'logs:PutLogEvents',\n          'logs:DescribeLogStream',\n        ],\n        effect: iam.Effect.ALLOW,\n      }),\n    ],\n  });\n\n  const indexRole: iam.Role = new iam.Role(scope, `kendra-index-role-${id}`, {\n    assumedBy: new iam.ServicePrincipal('kendra.amazonaws.com'),\n    description: 'Allow Kendra index to write CloudWatch Logs',\n    inlinePolicies: {\n      AllowLogging: allowKendraToLogPolicy,\n    },\n  });\n  addCfnSuppressRules(indexRole, [{\n    id: \"W11\",\n    reason: \"PutMetricData does not allow resource specification, \" +\n      \"scope is narrowed by the namespace condition. \" +\n      \"https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatch.html\"\n  }]);\n  return indexRole.roleArn;\n}\n\n// @summary Confirm each entry is a correct value, uppercase each entry\nexport function normalizeKendraPermissions(rawPermissions: string[]): string[] {\n  const validPermissions = [\"READ\", \"SUBMITFEEDBACK\", \"WRITE\"];\n\n  const result = rawPermissions.map<string>((s) => {\n    const upperCaseValue = s.toUpperCase();\n    if (!validPermissions.includes(upperCaseValue)) {\n      throw new Error(`Invalid indexPermission value - valid values are \"READ\", \"SUBMITFEEDBACK\" and \"WRITE\"`);\n    }\n    return upperCaseValue;\n  });\n  return result;\n}\n"]}

package/lib/lambda-helper.d.ts

@@ -36,11 +36,11 @@ export interface BuildLambdaFunctionProps {
 /**
  * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
  */
-export declare function buildLambdaFunction(scope: Construct, props: BuildLambdaFunctionProps): lambda.Function;
+export declare function buildLambdaFunction(scope: Construct, props: BuildLambdaFunctionProps, constructId?: string): lambda.Function;
 /**
  * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
  */
-export declare function deployLambdaFunction(scope: Construct, lambdaFunctionProps: lambda.FunctionProps, functionId?: string, vpc?: ec2.IVpc): lambda.Function;
+export declare function deployLambdaFunction(scope: Construct, lambdaFunctionProps: lambda.FunctionProps, constructId?: string, vpc?: ec2.IVpc): lambda.Function;
 /**
  * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
  *

package/lib/lambda-helper.js

@@ -26,11 +26,14 @@ const security_group_helper_1 = require("./security-group-helper");
 /**
  * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
  */
-function buildLambdaFunction(scope, props) {
+function buildLambdaFunction(scope, props, constructId) {
     // Conditional lambda function creation
     if (!props.existingLambdaObj) {
         if (props.lambdaFunctionProps) {
-            return deployLambdaFunction(scope, props.lambdaFunctionProps, props.lambdaFunctionProps.functionName, props.vpc);
+            // constructId may be specified by the calling code, but if not, fallback to the original behavior of using the
+            // function name as the construct id used when creating the underlying lambda function and iam role.
+            constructId = constructId ?? props.lambdaFunctionProps.functionName;
+            return deployLambdaFunction(scope, props.lambdaFunctionProps, constructId, props.vpc);
         }
         else {
             throw Error('Either existingLambdaObj or lambdaFunctionProps is required');
@@ -57,14 +60,14 @@ exports.buildLambdaFunction = buildLambdaFunction;
 /**
  * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
  */
-function deployLambdaFunction(scope, lambdaFunctionProps, functionId, vpc) {
-    const _functionId = functionId ? functionId : 'LambdaFunction';
-    const _functionRoleId = _functionId + 'ServiceRole';
+function deployLambdaFunction(scope, lambdaFunctionProps, constructId, vpc) {
+    const functionId = constructId ?? 'LambdaFunction';
+    const functionRoleId = functionId + 'ServiceRole';
     if (vpc && lambdaFunctionProps.vpc) {
         throw new Error("Cannot provide a VPC in both the lambdaFunctionProps and the function argument");
     }
     // Setup the IAM Role for Lambda Service
-    const lambdaServiceRole = new iam.Role(scope, _functionRoleId, {
+    const lambdaServiceRole = new iam.Role(scope, functionRoleId, {
         assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
         inlinePolicies: {
             LambdaFunctionServiceRolePolicy: new iam.PolicyDocument({
@@ -107,7 +110,7 @@ function deployLambdaFunction(scope, lambdaFunctionProps, functionId, vpc) {
             vpc,
         }, true);
     }
-    const lambdafunction = new lambda.Function(scope, _functionId, finalLambdaFunctionProps);
+    const lambdafunction = new lambda.Function(scope, functionId, finalLambdaFunctionProps);
     if (lambdaFunctionProps.runtime === lambda.Runtime.NODEJS_16_X) {
         lambdafunction.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
     }
@@ -179,4 +182,4 @@ function getLambdaVpcSecurityGroupIds(lambdaFunction) {
     return securityGroupIds;
 }
 exports.getLambdaVpcSecurityGroupIds = getLambdaVpcSecurityGroupIds;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-helper.js","sourceRoot":"","sources":["lambda-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 lambda from 'aws-cdk-lib/aws-lambda';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { DefaultLambdaFunctionProps } from './lambda-defaults';\nimport * as cdk from 'aws-cdk-lib';\nimport { overrideProps, addCfnSuppressRules } from './utils';\nimport { buildSecurityGroup } from \"./security-group-helper\";\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct, IConstruct } from 'constructs';\n\nexport interface BuildLambdaFunctionProps {\n  /**\n   * Existing instance of Lambda Function object, Providing both this and lambdaFunctionProps will cause an error.\n   *\n   * @default - None\n   */\n  readonly existingLambdaObj?: lambda.Function;\n  /**\n   * User provided props to override the default props for the Lambda function.\n   *\n   * @default - Default props are used\n   */\n  readonly lambdaFunctionProps?: lambda.FunctionProps;\n  /**\n   * A VPC where the Lambda function will access internal resources\n   *\n   * @default - none\n   */\n  readonly vpc?: ec2.IVpc;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildLambdaFunction(scope: Construct, props: BuildLambdaFunctionProps): lambda.Function {\n  // Conditional lambda function creation\n  if (!props.existingLambdaObj) {\n    if (props.lambdaFunctionProps) {\n      return deployLambdaFunction(scope, props.lambdaFunctionProps, props.lambdaFunctionProps.functionName, props.vpc);\n    } else {\n      throw Error('Either existingLambdaObj or lambdaFunctionProps is required');\n    }\n  } else {\n    if (props.vpc) {\n      const levelOneFunction: lambda.CfnFunction = props.existingLambdaObj.node.defaultChild as lambda.CfnFunction;\n      if (props.lambdaFunctionProps?.securityGroups) {\n        let ctr = 20;\n        props.lambdaFunctionProps?.securityGroups.forEach(sg => {\n          // It appears we can't get R/O access to VpcConfigSecurityGroupIds, such access would make this cleaner\n          levelOneFunction.addOverride(`Properties.VpcConfig.SecurityGroupIds.${ctr++}`, sg.securityGroupId);\n        });\n      }\n      if (!props.existingLambdaObj.isBoundToVpc) {\n        throw Error('A Lambda function must be bound to a VPC upon creation, it cannot be added to a VPC in a subsequent construct');\n      }\n    }\n    return props.existingLambdaObj;\n  }\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function deployLambdaFunction(scope: Construct,\n  lambdaFunctionProps: lambda.FunctionProps,\n  functionId?: string,\n  vpc?: ec2.IVpc): lambda.Function {\n\n  const _functionId = functionId ? functionId : 'LambdaFunction';\n  const _functionRoleId = _functionId + 'ServiceRole';\n\n  if (vpc && lambdaFunctionProps.vpc) {\n    throw new Error(\n      \"Cannot provide a VPC in both the lambdaFunctionProps and the function argument\"\n    );\n  }\n\n  // Setup the IAM Role for Lambda Service\n  const lambdaServiceRole = new iam.Role(scope, _functionRoleId, {\n    assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n    inlinePolicies: {\n      LambdaFunctionServiceRolePolicy: new iam.PolicyDocument({\n        statements: [new iam.PolicyStatement({\n          actions: [\n            'logs:CreateLogGroup',\n            'logs:CreateLogStream',\n            'logs:PutLogEvents'\n          ],\n          resources: [`arn:${cdk.Aws.PARTITION}:logs:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:log-group:/aws/lambda/*`]\n        })]\n      })\n    }\n  });\n\n  // If this Lambda function is going to access resoures in a\n  // VPC, then it needs privileges to access an ENI in that VPC\n  if (lambdaFunctionProps.vpc || vpc) {\n    lambdaServiceRole.addToPolicy(new iam.PolicyStatement({\n      actions: [\n        \"ec2:CreateNetworkInterface\",\n        \"ec2:DescribeNetworkInterfaces\",\n        \"ec2:DeleteNetworkInterface\",\n        \"ec2:AssignPrivateIpAddresses\",\n        \"ec2:UnassignPrivateIpAddresses\"\n      ],\n      resources: [\"*\"]\n    }));\n  }\n\n  // Override the DefaultFunctionProps with user provided  lambdaFunctionProps\n  let finalLambdaFunctionProps: lambda.FunctionProps = overrideProps(DefaultLambdaFunctionProps(lambdaServiceRole), lambdaFunctionProps);\n\n  if (vpc) {\n\n    // This is literally setting up what would be the default SG, but\n    // we need to to it explicitly to disable the cfn_nag error\n    const lambdaSecurityGroup = buildSecurityGroup(\n      scope,\n      \"ReplaceDefaultSecurityGroup\",\n      {\n        vpc,\n        allowAllOutbound: true,\n      },\n      [],\n      []\n    );\n\n    finalLambdaFunctionProps = overrideProps(finalLambdaFunctionProps, {\n      securityGroups: [lambdaSecurityGroup],\n      vpc,\n    }, true);\n  }\n\n  const lambdafunction = new lambda.Function(scope, _functionId, finalLambdaFunctionProps);\n\n  if (lambdaFunctionProps.runtime === lambda.Runtime.NODEJS_16_X) {\n    lambdafunction.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });\n  }\n\n  const cfnLambdafunction: lambda.CfnFunction = lambdafunction.node.findChild('Resource') as lambda.CfnFunction;\n\n  addCfnSuppressRules(lambdafunction, [\n    {\n      id: 'W58',\n      reason: `Lambda functions has the required permission to write CloudWatch Logs. It uses custom policy instead of arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole with tighter permissions.`\n    },\n    {\n      id: 'W89',\n      reason: `This is not a rule for the general case, just for specific use cases/industries`\n    },\n    {\n      id: 'W92',\n      reason: `Impossible for us to define the correct concurrency for clients`\n    }\n  ]);\n\n  if (cfnLambdafunction.tracingConfig) {\n    // Find the X-Ray IAM Policy\n    const cfnLambdafunctionDefPolicy = lambdafunction.role?.node.tryFindChild('DefaultPolicy')?.node.findChild('Resource') as iam.CfnPolicy;\n\n    // Add the CFN NAG suppress to allow for \"Resource\": \"*\" for AWS X-Ray\n    addCfnSuppressRules(cfnLambdafunctionDefPolicy, [\n      {\n        id: 'W12',\n        reason: `Lambda needs the following minimum required permissions to send trace data to X-Ray and access ENIs in a VPC.`\n      }\n    ]);\n  }\n\n  return lambdafunction;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * A wrapper above Function.addPermision that\n * prevents two different calls to addPermission using\n * the same construct id.\n */\nexport function addPermission(targetFunction: lambda.Function, name: string, permission: lambda.Permission): any {\n  targetFunction.addPermission(GetNextId(targetFunction.permissionsNode.children, name), permission);\n}\n\n// Scan the current permissions for any entries with this core name and\n// return the first available synthesized name. Names are coreName-suffix.\nfunction GetNextId(children: IConstruct[], coreName: string): string {\n  let lastSuffix: number = 0;\n\n  children.forEach(child => {\n\n    // if (compare right side of string)\n    if (child.node.id.indexOf(coreName) === 0) {\n      const components = child.node.id.split('-');\n      if (components.length !== 2) {\n        throw new Error(\"Incorrectly formatted synthesized construct ID\");\n      }\n\n      const usedSuffix = Number(components[1]);\n      if (usedSuffix > lastSuffix) {\n        lastSuffix = usedSuffix;\n      }\n    }\n\n  });\n\n  return `${coreName}-${lastSuffix + 1}`;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function getLambdaVpcSecurityGroupIds(lambdaFunction: lambda.Function): string[] {\n  const securityGroupIds: string[] = [];\n\n  lambdaFunction.connections.securityGroups.forEach(element => securityGroupIds.push(element.securityGroupId));\n\n  return securityGroupIds;\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-helper.js","sourceRoot":"","sources":["lambda-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 lambda from 'aws-cdk-lib/aws-lambda';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { DefaultLambdaFunctionProps } from './lambda-defaults';\nimport * as cdk from 'aws-cdk-lib';\nimport { overrideProps, addCfnSuppressRules } from './utils';\nimport { buildSecurityGroup } from \"./security-group-helper\";\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct, IConstruct } from 'constructs';\n\nexport interface BuildLambdaFunctionProps {\n  /**\n   * Existing instance of Lambda Function object, Providing both this and lambdaFunctionProps will cause an error.\n   *\n   * @default - None\n   */\n  readonly existingLambdaObj?: lambda.Function;\n  /**\n   * User provided props to override the default props for the Lambda function.\n   *\n   * @default - Default props are used\n   */\n  readonly lambdaFunctionProps?: lambda.FunctionProps;\n  /**\n   * A VPC where the Lambda function will access internal resources\n   *\n   * @default - none\n   */\n  readonly vpc?: ec2.IVpc;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildLambdaFunction(scope: Construct, props: BuildLambdaFunctionProps, constructId?: string): lambda.Function {\n  // Conditional lambda function creation\n  if (!props.existingLambdaObj) {\n    if (props.lambdaFunctionProps) {\n      // constructId may be specified by the calling code, but if not, fallback to the original behavior of using the\n      // function name as the construct id used when creating the underlying lambda function and iam role.\n      constructId = constructId ?? props.lambdaFunctionProps.functionName;\n      return deployLambdaFunction(scope, props.lambdaFunctionProps, constructId, props.vpc);\n    } else {\n      throw Error('Either existingLambdaObj or lambdaFunctionProps is required');\n    }\n  } else {\n    if (props.vpc) {\n      const levelOneFunction: lambda.CfnFunction = props.existingLambdaObj.node.defaultChild as lambda.CfnFunction;\n      if (props.lambdaFunctionProps?.securityGroups) {\n        let ctr = 20;\n        props.lambdaFunctionProps?.securityGroups.forEach(sg => {\n          // It appears we can't get R/O access to VpcConfigSecurityGroupIds, such access would make this cleaner\n          levelOneFunction.addOverride(`Properties.VpcConfig.SecurityGroupIds.${ctr++}`, sg.securityGroupId);\n        });\n      }\n      if (!props.existingLambdaObj.isBoundToVpc) {\n        throw Error('A Lambda function must be bound to a VPC upon creation, it cannot be added to a VPC in a subsequent construct');\n      }\n    }\n    return props.existingLambdaObj;\n  }\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function deployLambdaFunction(scope: Construct,\n  lambdaFunctionProps: lambda.FunctionProps,\n  constructId?: string,\n  vpc?: ec2.IVpc): lambda.Function {\n\n  const functionId = constructId ?? 'LambdaFunction';\n  const functionRoleId = functionId + 'ServiceRole';\n\n  if (vpc && lambdaFunctionProps.vpc) {\n    throw new Error(\n      \"Cannot provide a VPC in both the lambdaFunctionProps and the function argument\"\n    );\n  }\n\n  // Setup the IAM Role for Lambda Service\n  const lambdaServiceRole = new iam.Role(scope, functionRoleId, {\n    assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n    inlinePolicies: {\n      LambdaFunctionServiceRolePolicy: new iam.PolicyDocument({\n        statements: [new iam.PolicyStatement({\n          actions: [\n            'logs:CreateLogGroup',\n            'logs:CreateLogStream',\n            'logs:PutLogEvents'\n          ],\n          resources: [`arn:${cdk.Aws.PARTITION}:logs:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:log-group:/aws/lambda/*`]\n        })]\n      })\n    }\n  });\n\n  // If this Lambda function is going to access resoures in a\n  // VPC, then it needs privileges to access an ENI in that VPC\n  if (lambdaFunctionProps.vpc || vpc) {\n    lambdaServiceRole.addToPolicy(new iam.PolicyStatement({\n      actions: [\n        \"ec2:CreateNetworkInterface\",\n        \"ec2:DescribeNetworkInterfaces\",\n        \"ec2:DeleteNetworkInterface\",\n        \"ec2:AssignPrivateIpAddresses\",\n        \"ec2:UnassignPrivateIpAddresses\"\n      ],\n      resources: [\"*\"]\n    }));\n  }\n\n  // Override the DefaultFunctionProps with user provided  lambdaFunctionProps\n  let finalLambdaFunctionProps: lambda.FunctionProps = overrideProps(DefaultLambdaFunctionProps(lambdaServiceRole), lambdaFunctionProps);\n\n  if (vpc) {\n\n    // This is literally setting up what would be the default SG, but\n    // we need to to it explicitly to disable the cfn_nag error\n    const lambdaSecurityGroup = buildSecurityGroup(\n      scope,\n      \"ReplaceDefaultSecurityGroup\",\n      {\n        vpc,\n        allowAllOutbound: true,\n      },\n      [],\n      []\n    );\n\n    finalLambdaFunctionProps = overrideProps(finalLambdaFunctionProps, {\n      securityGroups: [lambdaSecurityGroup],\n      vpc,\n    }, true);\n  }\n\n  const lambdafunction = new lambda.Function(scope, functionId, finalLambdaFunctionProps);\n\n  if (lambdaFunctionProps.runtime === lambda.Runtime.NODEJS_16_X) {\n    lambdafunction.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });\n  }\n\n  const cfnLambdafunction: lambda.CfnFunction = lambdafunction.node.findChild('Resource') as lambda.CfnFunction;\n\n  addCfnSuppressRules(lambdafunction, [\n    {\n      id: 'W58',\n      reason: `Lambda functions has the required permission to write CloudWatch Logs. It uses custom policy instead of arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole with tighter permissions.`\n    },\n    {\n      id: 'W89',\n      reason: `This is not a rule for the general case, just for specific use cases/industries`\n    },\n    {\n      id: 'W92',\n      reason: `Impossible for us to define the correct concurrency for clients`\n    }\n  ]);\n\n  if (cfnLambdafunction.tracingConfig) {\n    // Find the X-Ray IAM Policy\n    const cfnLambdafunctionDefPolicy = lambdafunction.role?.node.tryFindChild('DefaultPolicy')?.node.findChild('Resource') as iam.CfnPolicy;\n\n    // Add the CFN NAG suppress to allow for \"Resource\": \"*\" for AWS X-Ray\n    addCfnSuppressRules(cfnLambdafunctionDefPolicy, [\n      {\n        id: 'W12',\n        reason: `Lambda needs the following minimum required permissions to send trace data to X-Ray and access ENIs in a VPC.`\n      }\n    ]);\n  }\n\n  return lambdafunction;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * A wrapper above Function.addPermision that\n * prevents two different calls to addPermission using\n * the same construct id.\n */\nexport function addPermission(targetFunction: lambda.Function, name: string, permission: lambda.Permission): any {\n  targetFunction.addPermission(GetNextId(targetFunction.permissionsNode.children, name), permission);\n}\n\n// Scan the current permissions for any entries with this core name and\n// return the first available synthesized name. Names are coreName-suffix.\nfunction GetNextId(children: IConstruct[], coreName: string): string {\n  let lastSuffix: number = 0;\n\n  children.forEach(child => {\n\n    // if (compare right side of string)\n    if (child.node.id.indexOf(coreName) === 0) {\n      const components = child.node.id.split('-');\n      if (components.length !== 2) {\n        throw new Error(\"Incorrectly formatted synthesized construct ID\");\n      }\n\n      const usedSuffix = Number(components[1]);\n      if (usedSuffix > lastSuffix) {\n        lastSuffix = usedSuffix;\n      }\n    }\n\n  });\n\n  return `${coreName}-${lastSuffix + 1}`;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function getLambdaVpcSecurityGroupIds(lambdaFunction: lambda.Function): string[] {\n  const securityGroupIds: string[] = [];\n\n  lambdaFunction.connections.securityGroups.forEach(element => securityGroupIds.push(element.securityGroupId));\n\n  return securityGroupIds;\n}"]}

package/lib/vpc-helper.d.ts

@@ -48,7 +48,8 @@ export declare enum ServiceEndpointTypes {
     ECR_DKR = "ECR_DKR",
     EVENTS = "CLOUDWATCH_EVENTS",
     KINESIS_FIREHOSE = "KINESIS_FIREHOSE",
-    KINESIS_STREAMS = "KINESIS_STREAMS"
+    KINESIS_STREAMS = "KINESIS_STREAMS",
+    KENDRA = "KENDRA"
 }
 /**
  * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.

package/lib/vpc-helper.js

@@ -52,6 +52,7 @@ var ServiceEndpointTypes;
     ServiceEndpointTypes["EVENTS"] = "CLOUDWATCH_EVENTS";
     ServiceEndpointTypes["KINESIS_FIREHOSE"] = "KINESIS_FIREHOSE";
     ServiceEndpointTypes["KINESIS_STREAMS"] = "KINESIS_STREAMS";
+    ServiceEndpointTypes["KENDRA"] = "KENDRA";
 })(ServiceEndpointTypes = exports.ServiceEndpointTypes || (exports.ServiceEndpointTypes = {}));
 var EndpointTypes;
 (function (EndpointTypes) {
@@ -123,6 +124,11 @@ const endpointSettings = [
         endpointName: ServiceEndpointTypes.KINESIS_STREAMS,
         endpointType: EndpointTypes.INTERFACE,
         endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KINESIS_STREAMS
+    },
+    {
+        endpointName: ServiceEndpointTypes.KENDRA,
+        endpointType: EndpointTypes.INTERFACE,
+        endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KENDRA
     }
 ];
 /**
@@ -207,4 +213,4 @@ function retrievePrivateSubnetIds(vpc) {
     return vpc.selectSubnets(subnetSelector).subnetIds;
 }
 exports.retrievePrivateSubnetIds = retrievePrivateSubnetIds;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-helper.js","sourceRoot":"","sources":["vpc-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 ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { CfnLogGroup } from \"aws-cdk-lib/aws-logs\";\nimport { Construct } from \"constructs\";\nimport { buildSecurityGroup } from \"./security-group-helper\";\nimport { consolidateProps, addCfnSuppressRules } from \"./utils\";\n\nexport interface BuildVpcProps {\n  /**\n   * Existing instance of a VPC, if this is set then the all Props are ignored\n   */\n  readonly existingVpc?: ec2.IVpc;\n  /**\n   * One of the default VPC configurations available in vpc-defaults\n   */\n  readonly defaultVpcProps: ec2.VpcProps;\n  /**\n   * User provided props to override the default props for the VPC.\n   */\n  readonly userVpcProps?: ec2.VpcProps;\n  /**\n   * Construct specified props that override both the default props\n   * and user props for the VPC.\n   */\n  readonly constructVpcProps?: ec2.VpcProps;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildVpc(scope: Construct, props: BuildVpcProps): ec2.IVpc {\n  if (props?.existingVpc) {\n    return props?.existingVpc;\n  }\n\n  let cumulativeProps: ec2.VpcProps = props?.defaultVpcProps;\n\n  cumulativeProps = consolidateProps(cumulativeProps, props?.userVpcProps, props?.constructVpcProps);\n\n  const vpc = new ec2.Vpc(scope, \"Vpc\", cumulativeProps);\n\n  // Add VPC FlowLogs with the default setting of trafficType:ALL and destination: CloudWatch Logs\n  const flowLog: ec2.FlowLog = vpc.addFlowLog(\"FlowLog\");\n\n  SuppressMapPublicIpWarnings(vpc);\n  SuppressEncryptedLogWarnings(flowLog);\n\n  return vpc;\n}\n\nexport enum ServiceEndpointTypes {\n  DYNAMODB = \"DDB\",\n  SNS = \"SNS\",\n  SQS = \"SQS\",\n  S3 = \"S3\",\n  STEP_FUNCTIONS = \"STEP_FUNCTIONS\",\n  SAGEMAKER_RUNTIME = \"SAGEMAKER_RUNTIME\",\n  SECRETS_MANAGER = \"SECRETS_MANAGER\",\n  SSM = \"SSM\",\n  ECR_API = \"ECR_API\",\n  ECR_DKR = \"ECR_DKR\",\n  EVENTS = \"CLOUDWATCH_EVENTS\",\n  KINESIS_FIREHOSE = \"KINESIS_FIREHOSE\",\n  KINESIS_STREAMS = \"KINESIS_STREAMS\"\n}\n\nenum EndpointTypes {\n  GATEWAY = \"Gateway\",\n  INTERFACE = \"Interface\",\n}\n\ninterface EndpointDefinition {\n  endpointName: ServiceEndpointTypes;\n  endpointType: EndpointTypes;\n  endpointGatewayService?: ec2.GatewayVpcEndpointAwsService;\n  endpointInterfaceService?: ec2.InterfaceVpcEndpointAwsService;\n}\n\nconst endpointSettings: EndpointDefinition[] = [\n  {\n    endpointName: ServiceEndpointTypes.DYNAMODB,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.DYNAMODB,\n  },\n  {\n    endpointName: ServiceEndpointTypes.S3,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.S3,\n  },\n  {\n    endpointName: ServiceEndpointTypes.STEP_FUNCTIONS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.STEP_FUNCTIONS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SNS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SNS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SQS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SQS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SAGEMAKER_RUNTIME,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SAGEMAKER_RUNTIME,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SECRETS_MANAGER,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SSM,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SSM,\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_API,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_DKR,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER\n  },\n  {\n    endpointName: ServiceEndpointTypes.EVENTS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_EVENTS\n  },\n  {\n    endpointName: ServiceEndpointTypes.KINESIS_FIREHOSE,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KINESIS_FIREHOSE\n  },\n  {\n    endpointName: ServiceEndpointTypes.KINESIS_STREAMS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KINESIS_STREAMS\n  }\n];\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function AddAwsServiceEndpoint(\n  scope: Construct,\n  vpc: ec2.IVpc,\n  interfaceTag: ServiceEndpointTypes\n) {\n  if (CheckIfEndpointAlreadyExists(vpc, interfaceTag)) {\n    return;\n  }\n\n  const service = endpointSettings.find(\n    (endpoint) => endpoint.endpointName === interfaceTag\n  );\n\n  if (!service) {\n    throw new Error(\"Unsupported Service sent to AddServiceEndpoint\");\n  }\n\n  if (service.endpointType === EndpointTypes.GATEWAY) {\n    AddGatewayEndpoint(vpc, service, interfaceTag);\n  }\n  if (service.endpointType === EndpointTypes.INTERFACE) {\n    AddInterfaceEndpoint(scope, vpc, service, interfaceTag);\n  }\n\n  // ESLint requires this return statement, so disabling SonarQube warning\n  return; // NOSONAR\n}\n\nfunction CheckIfEndpointAlreadyExists(vpc: ec2.IVpc, interfaceTag: ServiceEndpointTypes): boolean {\n  return vpc.node.children.some((child) => child.node.id === interfaceTag);\n}\n\nfunction SuppressMapPublicIpWarnings(vpc: ec2.Vpc) {\n  // Add Cfn Nag suppression for PUBLIC subnets to suppress WARN W33: EC2 Subnet should not have MapPublicIpOnLaunch set to true\n  vpc.publicSubnets.forEach((subnet) => {\n    const cfnSubnet = subnet.node.defaultChild as ec2.CfnSubnet;\n    addCfnSuppressRules(cfnSubnet, [\n      {\n        id: 'W33',\n        reason: 'Allow Public Subnets to have MapPublicIpOnLaunch set to true'\n      }\n    ]);\n  });\n}\n\nfunction SuppressEncryptedLogWarnings(flowLog: ec2.FlowLog) {\n  // Add Cfn Nag suppression for CloudWatchLogs LogGroups data is encrypted\n  const cfnLogGroup: CfnLogGroup = flowLog.logGroup?.node.defaultChild as CfnLogGroup;\n  addCfnSuppressRules(cfnLogGroup, [\n    {\n      id: 'W84',\n      reason: 'By default CloudWatchLogs LogGroups data is encrypted using the CloudWatch server-side encryption keys (AWS Managed Keys)'\n    }\n  ]);\n}\n\nfunction AddInterfaceEndpoint(scope: Construct, vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  const endpointDefaultSecurityGroup = buildSecurityGroup(\n    scope,\n    `${scope.node.id}-${service.endpointName}`,\n    {\n      vpc,\n      allowAllOutbound: true,\n    },\n    [{ peer: ec2.Peer.ipv4(vpc.vpcCidrBlock), connection: ec2.Port.tcp(443) }],\n    []\n  );\n\n  vpc.addInterfaceEndpoint(interfaceTag, {\n    service: service.endpointInterfaceService as ec2.InterfaceVpcEndpointAwsService,\n    securityGroups: [endpointDefaultSecurityGroup],\n  });\n}\n\nfunction AddGatewayEndpoint(vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  vpc.addGatewayEndpoint(interfaceTag, {\n    service: service.endpointGatewayService as ec2.GatewayVpcEndpointAwsService,\n  });\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function retrievePrivateSubnetIds(vpc: ec2.IVpc) {\n  let targetSubnetType;\n\n  if (vpc.isolatedSubnets.length) {\n    targetSubnetType = ec2.SubnetType.PRIVATE_ISOLATED;\n  } else if (vpc.privateSubnets.length) {\n    targetSubnetType = ec2.SubnetType.PRIVATE_WITH_EGRESS;\n  } else {\n    throw new Error('Error - No isolated or private subnets available in VPC');\n  }\n\n  const subnetSelector = {\n    onePerAz: true,\n    subnetType: targetSubnetType\n  };\n\n  return vpc.selectSubnets(subnetSelector).subnetIds;\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-helper.js","sourceRoot":"","sources":["vpc-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 ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { CfnLogGroup } from \"aws-cdk-lib/aws-logs\";\nimport { Construct } from \"constructs\";\nimport { buildSecurityGroup } from \"./security-group-helper\";\nimport { consolidateProps, addCfnSuppressRules } from \"./utils\";\n\nexport interface BuildVpcProps {\n  /**\n   * Existing instance of a VPC, if this is set then the all Props are ignored\n   */\n  readonly existingVpc?: ec2.IVpc;\n  /**\n   * One of the default VPC configurations available in vpc-defaults\n   */\n  readonly defaultVpcProps: ec2.VpcProps;\n  /**\n   * User provided props to override the default props for the VPC.\n   */\n  readonly userVpcProps?: ec2.VpcProps;\n  /**\n   * Construct specified props that override both the default props\n   * and user props for the VPC.\n   */\n  readonly constructVpcProps?: ec2.VpcProps;\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildVpc(scope: Construct, props: BuildVpcProps): ec2.IVpc {\n  if (props?.existingVpc) {\n    return props?.existingVpc;\n  }\n\n  let cumulativeProps: ec2.VpcProps = props?.defaultVpcProps;\n\n  cumulativeProps = consolidateProps(cumulativeProps, props?.userVpcProps, props?.constructVpcProps);\n\n  const vpc = new ec2.Vpc(scope, \"Vpc\", cumulativeProps);\n\n  // Add VPC FlowLogs with the default setting of trafficType:ALL and destination: CloudWatch Logs\n  const flowLog: ec2.FlowLog = vpc.addFlowLog(\"FlowLog\");\n\n  SuppressMapPublicIpWarnings(vpc);\n  SuppressEncryptedLogWarnings(flowLog);\n\n  return vpc;\n}\n\nexport enum ServiceEndpointTypes {\n  DYNAMODB = \"DDB\",\n  SNS = \"SNS\",\n  SQS = \"SQS\",\n  S3 = \"S3\",\n  STEP_FUNCTIONS = \"STEP_FUNCTIONS\",\n  SAGEMAKER_RUNTIME = \"SAGEMAKER_RUNTIME\",\n  SECRETS_MANAGER = \"SECRETS_MANAGER\",\n  SSM = \"SSM\",\n  ECR_API = \"ECR_API\",\n  ECR_DKR = \"ECR_DKR\",\n  EVENTS = \"CLOUDWATCH_EVENTS\",\n  KINESIS_FIREHOSE = \"KINESIS_FIREHOSE\",\n  KINESIS_STREAMS = \"KINESIS_STREAMS\",\n  KENDRA = \"KENDRA\"\n}\n\nenum EndpointTypes {\n  GATEWAY = \"Gateway\",\n  INTERFACE = \"Interface\",\n}\n\ninterface EndpointDefinition {\n  endpointName: ServiceEndpointTypes;\n  endpointType: EndpointTypes;\n  endpointGatewayService?: ec2.GatewayVpcEndpointAwsService;\n  endpointInterfaceService?: ec2.InterfaceVpcEndpointAwsService;\n}\n\nconst endpointSettings: EndpointDefinition[] = [\n  {\n    endpointName: ServiceEndpointTypes.DYNAMODB,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.DYNAMODB,\n  },\n  {\n    endpointName: ServiceEndpointTypes.S3,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.S3,\n  },\n  {\n    endpointName: ServiceEndpointTypes.STEP_FUNCTIONS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.STEP_FUNCTIONS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SNS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SNS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SQS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SQS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SAGEMAKER_RUNTIME,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SAGEMAKER_RUNTIME,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SECRETS_MANAGER,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SSM,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SSM,\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_API,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_DKR,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER\n  },\n  {\n    endpointName: ServiceEndpointTypes.EVENTS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_EVENTS\n  },\n  {\n    endpointName: ServiceEndpointTypes.KINESIS_FIREHOSE,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KINESIS_FIREHOSE\n  },\n  {\n    endpointName: ServiceEndpointTypes.KINESIS_STREAMS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KINESIS_STREAMS\n  },\n  {\n    endpointName: ServiceEndpointTypes.KENDRA,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.KENDRA\n  }\n];\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function AddAwsServiceEndpoint(\n  scope: Construct,\n  vpc: ec2.IVpc,\n  interfaceTag: ServiceEndpointTypes\n) {\n  if (CheckIfEndpointAlreadyExists(vpc, interfaceTag)) {\n    return;\n  }\n\n  const service = endpointSettings.find(\n    (endpoint) => endpoint.endpointName === interfaceTag\n  );\n\n  if (!service) {\n    throw new Error(\"Unsupported Service sent to AddServiceEndpoint\");\n  }\n\n  if (service.endpointType === EndpointTypes.GATEWAY) {\n    AddGatewayEndpoint(vpc, service, interfaceTag);\n  }\n  if (service.endpointType === EndpointTypes.INTERFACE) {\n    AddInterfaceEndpoint(scope, vpc, service, interfaceTag);\n  }\n\n  // ESLint requires this return statement, so disabling SonarQube warning\n  return; // NOSONAR\n}\n\nfunction CheckIfEndpointAlreadyExists(vpc: ec2.IVpc, interfaceTag: ServiceEndpointTypes): boolean {\n  return vpc.node.children.some((child) => child.node.id === interfaceTag);\n}\n\nfunction SuppressMapPublicIpWarnings(vpc: ec2.Vpc) {\n  // Add Cfn Nag suppression for PUBLIC subnets to suppress WARN W33: EC2 Subnet should not have MapPublicIpOnLaunch set to true\n  vpc.publicSubnets.forEach((subnet) => {\n    const cfnSubnet = subnet.node.defaultChild as ec2.CfnSubnet;\n    addCfnSuppressRules(cfnSubnet, [\n      {\n        id: 'W33',\n        reason: 'Allow Public Subnets to have MapPublicIpOnLaunch set to true'\n      }\n    ]);\n  });\n}\n\nfunction SuppressEncryptedLogWarnings(flowLog: ec2.FlowLog) {\n  // Add Cfn Nag suppression for CloudWatchLogs LogGroups data is encrypted\n  const cfnLogGroup: CfnLogGroup = flowLog.logGroup?.node.defaultChild as CfnLogGroup;\n  addCfnSuppressRules(cfnLogGroup, [\n    {\n      id: 'W84',\n      reason: 'By default CloudWatchLogs LogGroups data is encrypted using the CloudWatch server-side encryption keys (AWS Managed Keys)'\n    }\n  ]);\n}\n\nfunction AddInterfaceEndpoint(scope: Construct, vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  const endpointDefaultSecurityGroup = buildSecurityGroup(\n    scope,\n    `${scope.node.id}-${service.endpointName}`,\n    {\n      vpc,\n      allowAllOutbound: true,\n    },\n    [{ peer: ec2.Peer.ipv4(vpc.vpcCidrBlock), connection: ec2.Port.tcp(443) }],\n    []\n  );\n\n  vpc.addInterfaceEndpoint(interfaceTag, {\n    service: service.endpointInterfaceService as ec2.InterfaceVpcEndpointAwsService,\n    securityGroups: [endpointDefaultSecurityGroup],\n  });\n}\n\nfunction AddGatewayEndpoint(vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  vpc.addGatewayEndpoint(interfaceTag, {\n    service: service.endpointGatewayService as ec2.GatewayVpcEndpointAwsService,\n  });\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function retrievePrivateSubnetIds(vpc: ec2.IVpc) {\n  let targetSubnetType;\n\n  if (vpc.isolatedSubnets.length) {\n    targetSubnetType = ec2.SubnetType.PRIVATE_ISOLATED;\n  } else if (vpc.privateSubnets.length) {\n    targetSubnetType = ec2.SubnetType.PRIVATE_WITH_EGRESS;\n  } else {\n    throw new Error('Error - No isolated or private subnets available in VPC');\n  }\n\n  const subnetSelector = {\n    onePerAz: true,\n    subnetType: targetSubnetType\n  };\n\n  return vpc.selectSubnets(subnetSelector).subnetIds;\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-solutions-constructs/core",
-  "version": "2.41.0",
+  "version": "2.43.0",
   "description": "Core CDK Construct for patterns library",
   "main": "index.js",
   "types": "index.ts",

package/test/kendra-helper.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ *  Copyright 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.
+ */
+export {};