@gemeentenijmegen/webapp 1.0.1 → 1.1.1

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/kendra-helper.js

@@ -0,0 +1,218 @@
+"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");
+/**
+ * @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 = (0, kendra_defaults_1.DefaultKendraIndexProps)(id, indexRoleArn);
+        const consolidatedIndexProperties = (0, utils_1.consolidateProps)(defaultIndexProperties, props.kendraIndexProps);
+        const newIndex = new kendra.CfnIndex(scope, `kendra-index-${id}`, consolidatedIndexProperties);
+        (0, 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 DataSourceConfiguration prop');
+    }
+    const s3DataSourceConfig = dataSourceConfig.s3Configuration;
+    if (!s3DataSourceConfig) {
+        throw new Error('Error - an S3 Kendra DataSource requires an DataSourceConfiguration.S3Configuration prop');
+    }
+    // No Bucket name is an error
+    if (!s3DataSourceConfig.bucketName) {
+        throw new Error('Error - an S3 Kendra DataSource requires the DataSourceConfiguration.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: (0, utils_1.generatePhysicalKendraIndexName)('', ['s3-datasource', id]),
+        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 = (0, utils_1.overrideProps)(defaultProps, { roleArn: dataSourceRole.roleArn });
+        (0, utils_1.addCfnGuardSuppressRules)(dataSourceRole, ["IAM_NO_INLINE_POLICY_CHECK"]);
+    }
+    const consolidatedProps = (0, 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,
+        },
+    });
+    (0, 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"
+        }]);
+    (0, utils_1.addCfnGuardSuppressRules)(indexRole, ["IAM_NO_INLINE_POLICY_CHECK"]);
+    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 { addCfnGuardSuppressRules, addCfnSuppressRules, consolidateProps, generatePhysicalKendraIndexName, overrideProps } 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';\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 DataSourceConfiguration 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 DataSourceConfiguration.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 DataSourceConfiguration.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: generatePhysicalKendraIndexName('', ['s3-datasource', id]),\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    addCfnGuardSuppressRules(dataSourceRole, [\"IAM_NO_INLINE_POLICY_CHECK\"]);\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  addCfnGuardSuppressRules(indexRole, [\"IAM_NO_INLINE_POLICY_CHECK\"]);\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/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/kinesis-analytics-helper.js

@@ -0,0 +1,60 @@
+"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.buildKinesisAnalyticsApp = 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.
+ */
+// Imports
+const kinesisAnalytics = require("aws-cdk-lib/aws-kinesisanalytics");
+const iam = require("aws-cdk-lib/aws-iam");
+const defaults = require("./kinesis-analytics-defaults");
+const utils_1 = require("./utils");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildKinesisAnalyticsApp(scope, props) {
+    // Setup the IAM role for Kinesis Analytics
+    const analyticsRole = new iam.Role(scope, 'KinesisAnalyticsRole', {
+        assumedBy: new iam.ServicePrincipal('kinesisanalytics.amazonaws.com'),
+    });
+    // Setup the IAM policy for Kinesis Analytics
+    const analyticsPolicy = new iam.Policy(scope, 'KinesisAnalyticsPolicy', {
+        statements: [
+            new iam.PolicyStatement({
+                actions: [
+                    'firehose:DescribeDeliveryStream',
+                    'firehose:Get*'
+                ],
+                resources: [props.kinesisFirehose.attrArn]
+            })
+        ]
+    });
+    // Attach policy to role
+    analyticsPolicy.attachToRole(analyticsRole);
+    // Setup the Kinesis application properties
+    const kinesisAnalyticsProps = (0, utils_1.overrideProps)(defaults.DefaultCfnApplicationProps, props.kinesisAnalyticsProps);
+    kinesisAnalyticsProps.inputs[0].kinesisFirehoseInput = {
+        resourceArn: props.kinesisFirehose.attrArn,
+        roleArn: analyticsRole.roleArn
+    };
+    // Setup the Kinesis application and add dependencies
+    const kinesisAnalyticsApp = new kinesisAnalytics.CfnApplication(scope, 'KinesisAnalytics', kinesisAnalyticsProps);
+    kinesisAnalyticsApp.addDependency(analyticsPolicy.node.findChild('Resource'));
+    // Create the application and return
+    return kinesisAnalyticsApp;
+}
+exports.buildKinesisAnalyticsApp = buildKinesisAnalyticsApp;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/kinesis-streams-helper.js

@@ -0,0 +1,88 @@
+"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.CheckKinesisStreamProps = exports.buildKinesisStreamCWAlarms = exports.buildKinesisStream = 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.
+ */
+// Imports
+const kinesis = require("aws-cdk-lib/aws-kinesis");
+const kinesis_streams_defaults_1 = require("./kinesis-streams-defaults");
+const cdk = require("aws-cdk-lib");
+const utils_1 = require("./utils");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildKinesisStream(scope, props) {
+    if (props.existingStreamObj) {
+        return props.existingStreamObj;
+    }
+    // Setup the stream properties
+    let kinesisStreamProps;
+    // If property overrides have been provided, incorporate them and deploy
+    kinesisStreamProps = (0, utils_1.consolidateProps)(kinesis_streams_defaults_1.DefaultStreamProps, props.kinesisStreamProps);
+    // Create the stream and return
+    return new kinesis.Stream(scope, 'KinesisStream', kinesisStreamProps);
+}
+exports.buildKinesisStream = buildKinesisStream;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildKinesisStreamCWAlarms(scope) {
+    // Setup CW Alarms for KinesisStream
+    const alarms = new Array();
+    // Alarm if Max (GetRecords.IteratorAgeMilliseconds): >= 12 hours (50% of 24 hours default retention period)
+    alarms.push(new cloudwatch.Alarm(scope, 'KinesisStreamGetRecordsIteratorAgeAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/Kinesis',
+            metricName: 'GetRecords.IteratorAgeMilliseconds',
+            statistic: 'Maximum',
+            period: cdk.Duration.minutes(5),
+        }),
+        threshold: 43200000, // 43200000 Milliseconds = 12 Hours (50% of 24 hours - default record retention period)
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Consumer Record Processing Falling Behind, there is risk for data loss due to record expiration.'
+    }));
+    // Alarm if Avg (ReadProvisionedThroughputExceeded): > 0
+    alarms.push(new cloudwatch.Alarm(scope, 'KinesisStreamReadProvisionedThroughputExceededAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/Kinesis',
+            metricName: 'ReadProvisionedThroughputExceeded',
+            statistic: 'Average',
+            period: cdk.Duration.minutes(5),
+        }),
+        threshold: 0,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+        alarmDescription: 'Consumer Application is Reading at a Slower Rate Than Expected.'
+    }));
+    return alarms;
+}
+exports.buildKinesisStreamCWAlarms = buildKinesisStreamCWAlarms;
+function CheckKinesisStreamProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (propsObject.existingStreamObj && propsObject.kinesisStreamProps) {
+        errorMessages += 'Error - Either provide existingStreamObj or kinesisStreamProps, but not both.\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+exports.CheckKinesisStreamProps = CheckKinesisStreamProps;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kinesis-streams-helper.js","sourceRoot":"","sources":["kinesis-streams-helper.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH;;;GAGG;AAEH,UAAU;AACV,mDAAmD;AACnD,yEAAgE;AAChE,mCAAmC;AACnC,mCAA2C;AAC3C,yDAAyD;AAoBzD;;GAEG;AACH,SAAgB,kBAAkB,CAAC,KAAgB,EAAE,KAA8B;IAEjF,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;QAC5B,OAAO,KAAK,CAAC,iBAAiB,CAAC;IACjC,CAAC;IAED,8BAA8B;IAC9B,IAAI,kBAAkB,CAAC;IACvB,wEAAwE;IACxE,kBAAkB,GAAG,IAAA,wBAAgB,EAAC,6CAAkB,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IAEpF,+BAA+B;IAC/B,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,eAAe,EAAE,kBAAkB,CAAC,CAAC;AACxE,CAAC;AAbD,gDAaC;AAED;;GAEG;AACH,SAAgB,0BAA0B,CAAC,KAAgB;IACzD,oCAAoC;IACpC,MAAM,MAAM,GAAuB,IAAI,KAAK,EAAE,CAAC;IAE/C,4GAA4G;IAC5G,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,yCAAyC,EAAE;QACjF,MAAM,EAAE,IAAI,UAAU,CAAC,MAAM,CAAC;YAC5B,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,oCAAoC;YAChD,SAAS,EAAE,SAAS;YACpB,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;SAChC,CAAC;QACF,SAAS,EAAE,QAAQ,EAAE,uFAAuF;QAC5G,iBAAiB,EAAE,CAAC;QACpB,kBAAkB,EAAE,UAAU,CAAC,kBAAkB,CAAC,kCAAkC;QACpF,gBAAgB,EAAE,kGAAkG;KACrH,CAAC,CAAC,CAAC;IAEJ,wDAAwD;IACxD,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,qDAAqD,EAAE;QAC7F,MAAM,EAAE,IAAI,UAAU,CAAC,MAAM,CAAC;YAC5B,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,mCAAmC;YAC/C,SAAS,EAAE,SAAS;YACpB,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;SAChC,CAAC;QACF,SAAS,EAAE,CAAC;QACZ,iBAAiB,EAAE,CAAC;QACpB,kBAAkB,EAAE,UAAU,CAAC,kBAAkB,CAAC,sBAAsB;QACxE,gBAAgB,EAAE,iEAAiE;KACpF,CAAC,CAAC,CAAC;IAEJ,OAAO,MAAM,CAAC;AAChB,CAAC;AAjCD,gEAiCC;AAOD,SAAgB,uBAAuB,CAAC,WAAqC;IAC3E,IAAI,aAAa,GAAG,EAAE,CAAC;IACvB,IAAI,UAAU,GAAG,KAAK,CAAC;IAEvB,IAAI,WAAW,CAAC,iBAAiB,IAAI,WAAW,CAAC,kBAAkB,EAAE,CAAC;QACpE,aAAa,IAAI,iFAAiF,CAAC;QACnG,UAAU,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,IAAI,UAAU,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;AACH,CAAC;AAZD,0DAYC","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\n// Imports\nimport * as kinesis from 'aws-cdk-lib/aws-kinesis';\nimport { DefaultStreamProps } from './kinesis-streams-defaults';\nimport * as cdk from 'aws-cdk-lib';\nimport { consolidateProps } from './utils';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\n\nexport interface BuildKinesisStreamProps {\n  /**\n   * Existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.\n   *\n   * @default - None\n   */\n  readonly existingStreamObj?: kinesis.Stream;\n\n  /**\n   * Optional user provided props to override the default props for the Kinesis stream.\n   *\n   * @default - Default props are used.\n   */\n  readonly kinesisStreamProps?: kinesis.StreamProps\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildKinesisStream(scope: Construct, props: BuildKinesisStreamProps): kinesis.Stream {\n\n  if (props.existingStreamObj) {\n    return props.existingStreamObj;\n  }\n\n  // Setup the stream properties\n  let kinesisStreamProps;\n  // If property overrides have been provided, incorporate them and deploy\n  kinesisStreamProps = consolidateProps(DefaultStreamProps, props.kinesisStreamProps);\n\n  // Create the stream and return\n  return new kinesis.Stream(scope, 'KinesisStream', kinesisStreamProps);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildKinesisStreamCWAlarms(scope: Construct): cloudwatch.Alarm[] {\n  // Setup CW Alarms for KinesisStream\n  const alarms: cloudwatch.Alarm[] = new Array();\n\n  // Alarm if Max (GetRecords.IteratorAgeMilliseconds): >= 12 hours (50% of 24 hours default retention period)\n  alarms.push(new cloudwatch.Alarm(scope, 'KinesisStreamGetRecordsIteratorAgeAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/Kinesis',\n      metricName: 'GetRecords.IteratorAgeMilliseconds',\n      statistic: 'Maximum',\n      period: cdk.Duration.minutes(5),\n    }),\n    threshold: 43200000, // 43200000 Milliseconds = 12 Hours (50% of 24 hours - default record retention period)\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Consumer Record Processing Falling Behind, there is risk for data loss due to record expiration.'\n  }));\n\n  // Alarm if Avg (ReadProvisionedThroughputExceeded): > 0\n  alarms.push(new cloudwatch.Alarm(scope, 'KinesisStreamReadProvisionedThroughputExceededAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/Kinesis',\n      metricName: 'ReadProvisionedThroughputExceeded',\n      statistic: 'Average',\n      period: cdk.Duration.minutes(5),\n    }),\n    threshold: 0,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n    alarmDescription: 'Consumer Application is Reading at a Slower Rate Than Expected.'\n  }));\n\n  return alarms;\n}\n\nexport interface KinesisStreamProps {\n  readonly existingStreamObj?: kinesis.Stream;\n  readonly kinesisStreamProps?: kinesis.StreamProps,\n}\n\nexport function CheckKinesisStreamProps(propsObject: KinesisStreamProps | any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (propsObject.existingStreamObj && propsObject.kinesisStreamProps) {\n    errorMessages += 'Error - Either provide existingStreamObj or kinesisStreamProps, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n"]}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/kms-helper.d.ts

@@ -0,0 +1,18 @@
+/**
+ *  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 kms from 'aws-cdk-lib/aws-kms';
+import { Construct } from 'constructs';
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildEncryptionKey(scope: Construct, id: string, keyProps?: kms.KeyProps): kms.Key;

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/kms-helper.js

@@ -0,0 +1,35 @@
+"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.buildEncryptionKey = 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 kms = require("aws-cdk-lib/aws-kms");
+const kms_defaults_1 = require("./kms-defaults");
+const utils_1 = require("./utils");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildEncryptionKey(scope, id, keyProps) {
+    // Setup the key properties
+    let encryptionKeyProps;
+    // If property overrides have been provided, incorporate them and deploy
+    encryptionKeyProps = (0, utils_1.consolidateProps)(kms_defaults_1.DefaultEncryptionProps, keyProps);
+    // Create the encryption key and return
+    return new kms.Key(scope, `'${id}Key'`, encryptionKeyProps);
+}
+exports.buildEncryptionKey = buildEncryptionKey;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/lambda-event-source-mapping-defaults.js

@@ -0,0 +1,82 @@
+"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.KinesisEventSourceProps = exports.S3EventSourceProps = exports.DynamoEventSourceProps = void 0;
+const lambda = require("aws-cdk-lib/aws-lambda");
+const utils_1 = require("./utils");
+const aws_lambda_event_sources_1 = require("aws-cdk-lib/aws-lambda-event-sources");
+const s3 = require("aws-cdk-lib/aws-s3");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const sqs_helper_1 = require("./sqs-helper");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function DynamoEventSourceProps(scope, _dynamoEventSourceProps) {
+    const baseProps = {
+        startingPosition: lambda.StartingPosition.TRIM_HORIZON,
+        bisectBatchOnError: true,
+        maxRecordAge: aws_cdk_lib_1.Duration.hours(24),
+        retryAttempts: 500
+    };
+    let extraProps = {};
+    if (_dynamoEventSourceProps === undefined || _dynamoEventSourceProps?.deploySqsDlqQueue === undefined
+        || _dynamoEventSourceProps.deploySqsDlqQueue) {
+        const buildQueueResponse = (0, sqs_helper_1.buildQueue)(scope, 'SqsDlqQueue', {
+            queueProps: _dynamoEventSourceProps?.sqsDlqQueueProps,
+            deployDeadLetterQueue: false // This is already a DLQ for the stream, it doesn't need it's own DLQS
+        });
+        extraProps = {
+            onFailure: new aws_lambda_event_sources_1.SqsDlq(buildQueueResponse.queue),
+        };
+    }
+    const defaultDynamoEventSourceProps = Object.assign(baseProps, extraProps);
+    return (0, utils_1.consolidateProps)(defaultDynamoEventSourceProps, _dynamoEventSourceProps?.eventSourceProps);
+}
+exports.DynamoEventSourceProps = DynamoEventSourceProps;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function S3EventSourceProps(_s3EventSourceProps) {
+    const defaultS3EventSourceProps = {
+        events: [s3.EventType.OBJECT_CREATED]
+    };
+    return (0, utils_1.consolidateProps)(defaultS3EventSourceProps, _s3EventSourceProps);
+}
+exports.S3EventSourceProps = S3EventSourceProps;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function KinesisEventSourceProps(scope, _kinesisEventSourceProps) {
+    const baseProps = {
+        startingPosition: lambda.StartingPosition.TRIM_HORIZON,
+        bisectBatchOnError: true,
+        maxRecordAge: aws_cdk_lib_1.Duration.hours(24),
+        retryAttempts: 500
+    };
+    let extraProps = {};
+    if (_kinesisEventSourceProps === undefined || _kinesisEventSourceProps?.deploySqsDlqQueue === undefined
+        || _kinesisEventSourceProps.deploySqsDlqQueue) {
+        const buildQueueResponse = (0, sqs_helper_1.buildQueue)(scope, 'SqsDlqQueue', {
+            queueProps: _kinesisEventSourceProps?.sqsDlqQueueProps,
+            deployDeadLetterQueue: false // Don't create SQS DLQ for Kinesis DLQ
+        });
+        extraProps = {
+            onFailure: new aws_lambda_event_sources_1.SqsDlq(buildQueueResponse.queue),
+        };
+    }
+    const defaultKinesisEventSourceProps = Object.assign(baseProps, extraProps);
+    return (0, utils_1.consolidateProps)(defaultKinesisEventSourceProps, _kinesisEventSourceProps?.eventSourceProps);
+}
+exports.KinesisEventSourceProps = KinesisEventSourceProps;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-event-source-mapping-defaults.js","sourceRoot":"","sources":["lambda-event-source-mapping-defaults.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAQH,iDAAiD;AACjD,mCAA2C;AAC3C,mFAA2J;AAC3J,yCAAyC;AACzC,6CAAuC;AAEvC,6CAA0C;AAQ1C;;GAEG;AACH,SAAgB,sBAAsB,CAAC,KAAgB,EAAE,uBAA0C;IAEjG,MAAM,SAAS,GAA2B;QACxC,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,CAAC,YAAY;QACtD,kBAAkB,EAAE,IAAI;QACxB,YAAY,EAAE,sBAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,aAAa,EAAE,GAAG;KACnB,CAAC;IAEF,IAAI,UAAU,GAAG,EAAE,CAAC;IAEpB,IAAI,uBAAuB,KAAK,SAAS,IAAI,uBAAuB,EAAE,iBAAiB,KAAK,SAAS;WAChG,uBAAuB,CAAC,iBAAiB,EAAE,CAAC;QAC/C,MAAM,kBAAkB,GAAG,IAAA,uBAAU,EAAC,KAAK,EAAE,aAAa,EAAE;YAC1D,UAAU,EAAE,uBAAuB,EAAE,gBAAgB;YACrD,qBAAqB,EAAE,KAAK,CAAG,sEAAsE;SACtG,CAAC,CAAC;QAEH,UAAU,GAAG;YACX,SAAS,EAAE,IAAI,iCAAM,CAAC,kBAAkB,CAAC,KAAK,CAAC;SAChD,CAAC;IACJ,CAAC;IAED,MAAM,6BAA6B,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAE3E,OAAO,IAAA,wBAAgB,EAAC,6BAA6B,EAAE,uBAAuB,EAAE,gBAAgB,CAAC,CAAC;AACpG,CAAC;AA1BD,wDA0BC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAAC,mBAAwC;IAEzE,MAAM,yBAAyB,GAAuB;QACpD,MAAM,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,cAAc,CAAC;KACtC,CAAC;IAEF,OAAO,IAAA,wBAAgB,EAAC,yBAAyB,EAAE,mBAAmB,CAAC,CAAC;AAC1E,CAAC;AAPD,gDAOC;AAED;;GAEG;AACH,SAAgB,uBAAuB,CAAC,KAAgB,EAAE,wBAA2C;IACnG,MAAM,SAAS,GAA4B;QACzC,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,CAAC,YAAY;QACtD,kBAAkB,EAAE,IAAI;QACxB,YAAY,EAAE,sBAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,aAAa,EAAE,GAAG;KACnB,CAAC;IAEF,IAAI,UAAU,GAAG,EAAE,CAAC;IAEpB,IAAI,wBAAwB,KAAK,SAAS,IAAI,wBAAwB,EAAE,iBAAiB,KAAK,SAAS;WAClG,wBAAwB,CAAC,iBAAiB,EAAE,CAAC;QAChD,MAAM,kBAAkB,GAAG,IAAA,uBAAU,EAAC,KAAK,EAAE,aAAa,EAAE;YAC1D,UAAU,EAAE,wBAAwB,EAAE,gBAAgB;YACtD,qBAAqB,EAAE,KAAK,CAAC,uCAAuC;SACrE,CAAC,CAAC;QAEH,UAAU,GAAG;YACX,SAAS,EAAE,IAAI,iCAAM,CAAC,kBAAkB,CAAC,KAAK,CAAC;SAChD,CAAC;IACJ,CAAC;IAED,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAE5E,OAAO,IAAA,wBAAgB,EAAC,8BAA8B,EAAE,wBAAwB,EAAE,gBAAgB,CAAC,CAAC;AACtG,CAAC;AAzBD,0DAyBC","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 { Construct } from 'constructs';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { consolidateProps } from './utils';\nimport { DynamoEventSourceProps, S3EventSourceProps, KinesisEventSourceProps, StreamEventSourceProps, SqsDlq } from 'aws-cdk-lib/aws-lambda-event-sources';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport { Duration } from 'aws-cdk-lib';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport { buildQueue } from './sqs-helper';\n\nexport interface EventSourceProps {\n  readonly eventSourceProps?: StreamEventSourceProps,\n  readonly deploySqsDlqQueue?: boolean,\n  readonly sqsDlqQueueProps?: sqs.QueueProps\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function DynamoEventSourceProps(scope: Construct, _dynamoEventSourceProps?: EventSourceProps): DynamoEventSourceProps {\n\n  const baseProps: DynamoEventSourceProps = {\n    startingPosition: lambda.StartingPosition.TRIM_HORIZON,\n    bisectBatchOnError: true,\n    maxRecordAge: Duration.hours(24),\n    retryAttempts: 500\n  };\n\n  let extraProps = {};\n\n  if (_dynamoEventSourceProps === undefined || _dynamoEventSourceProps?.deploySqsDlqQueue === undefined\n    || _dynamoEventSourceProps.deploySqsDlqQueue) {\n    const buildQueueResponse = buildQueue(scope, 'SqsDlqQueue', {\n      queueProps: _dynamoEventSourceProps?.sqsDlqQueueProps,\n      deployDeadLetterQueue: false   // This is already a DLQ for the stream, it doesn't need it's own DLQS\n    });\n\n    extraProps = {\n      onFailure: new SqsDlq(buildQueueResponse.queue),\n    };\n  }\n\n  const defaultDynamoEventSourceProps = Object.assign(baseProps, extraProps);\n\n  return consolidateProps(defaultDynamoEventSourceProps, _dynamoEventSourceProps?.eventSourceProps);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function S3EventSourceProps(_s3EventSourceProps?: S3EventSourceProps) {\n\n  const defaultS3EventSourceProps: S3EventSourceProps = {\n    events: [s3.EventType.OBJECT_CREATED]\n  };\n\n  return consolidateProps(defaultS3EventSourceProps, _s3EventSourceProps);\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function KinesisEventSourceProps(scope: Construct, _kinesisEventSourceProps?: EventSourceProps): KinesisEventSourceProps {\n  const baseProps: KinesisEventSourceProps = {\n    startingPosition: lambda.StartingPosition.TRIM_HORIZON,\n    bisectBatchOnError: true,\n    maxRecordAge: Duration.hours(24),\n    retryAttempts: 500\n  };\n\n  let extraProps = {};\n\n  if (_kinesisEventSourceProps === undefined || _kinesisEventSourceProps?.deploySqsDlqQueue === undefined\n    || _kinesisEventSourceProps.deploySqsDlqQueue) {\n    const buildQueueResponse = buildQueue(scope, 'SqsDlqQueue', {\n      queueProps: _kinesisEventSourceProps?.sqsDlqQueueProps,\n      deployDeadLetterQueue: false // Don't create SQS DLQ for Kinesis DLQ\n    });\n\n    extraProps = {\n      onFailure: new SqsDlq(buildQueueResponse.queue),\n    };\n  }\n\n  const defaultKinesisEventSourceProps = Object.assign(baseProps, extraProps);\n\n  return consolidateProps(defaultKinesisEventSourceProps, _kinesisEventSourceProps?.eventSourceProps);\n}\n"]}