@gemeentenijmegen/webapp 1.1.12 → 1.1.14

package/node_modules/@aws-solutions-constructs/core/lib/step-function-helper.js

@@ -0,0 +1,164 @@
+"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.idPlaceholder = void 0;
+exports.buildStateMachine = buildStateMachine;
+exports.buildStepFunctionCWAlarms = buildStepFunctionCWAlarms;
+exports.CheckStateMachineProps = CheckStateMachineProps;
+const cdk = require("aws-cdk-lib");
+const smDefaults = require("./step-function-defaults");
+const sfn = require("aws-cdk-lib/aws-stepfunctions");
+const utils_1 = require("./utils");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const cloudwatch_log_group_helper_1 = require("./cloudwatch-log-group-helper");
+/*
+ * the id parameter was added to buildStateMachine() long after the original implementation,
+ * this value can be used for the new parameter and ensure behavior is the same.
+ * (if we just require an id, the state machine name will be changed and it will be a
+ * destructive change)
+ */
+exports.idPlaceholder = undefined;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ *
+ * Builds and returns a StateMachine.
+ * @param scope - the construct to which the StateMachine should be attached to.
+ * @param stateMachineProps - user-specified properties to override the default properties.
+ */
+function buildStateMachine(scope, id, props) {
+    let logGroup;
+    let consolidatedStateMachineProps;
+    // If they sent a logGroup in stateMachineProps
+    if (props.stateMachineProps.logs?.destination) {
+        // In CDK v2.235.0+, logs.destination is ILogGroupRef, but we need ILogGroup
+        // We need to verify it's actually an ILogGroup (has the full interface)
+        const destination = props.stateMachineProps.logs.destination;
+        // Type guard: Check if destination has ILogGroup methods
+        if ('addMetricFilter' in destination && 'grantWrite' in destination) {
+            logGroup = destination;
+        }
+        else {
+            throw new Error('The provided log group destination must be a full ILogGroup (not just ILogGroupRef). ' +
+                'Please provide a LogGroup created with new LogGroup() or LogGroup.fromLogGroupArn().');
+        }
+        consolidatedStateMachineProps = props.stateMachineProps;
+    }
+    else {
+        // Three possibilities
+        // 1) logGroupProps not provided - create logGroupProps with just logGroupName
+        // 2) logGroupProps provided with no logGroupName - override logGroupProps.logGroupName
+        // 3) logGroupProps provided with logGroupName - pass unaltered logGroupProps
+        let consolidatedLogGroupProps = props.logGroupProps;
+        if (!consolidatedLogGroupProps) {
+            consolidatedLogGroupProps = {};
+        }
+        if (!consolidatedLogGroupProps?.logGroupName) {
+            const logGroupPrefix = '/aws/vendedlogs/states/constructs/';
+            const nameParts = [
+                cdk.Stack.of(scope).stackName, // Name of the stack
+                id ?? scope.node.id, // Use the ID from client if provided, otherwise use the construct ID
+                'StateMachineLog' // Literal string for log group name portion
+            ];
+            const logGroupName = (0, utils_1.generatePhysicalLogGroupName)(logGroupPrefix, nameParts);
+            consolidatedLogGroupProps = (0, utils_1.overrideProps)(consolidatedLogGroupProps, { logGroupName });
+        }
+        // Create new Cloudwatch log group for Step function State Machine
+        logGroup = (0, cloudwatch_log_group_helper_1.buildLogGroup)(scope, `StateMachineLogGroup${(id ?? '')}`, consolidatedLogGroupProps);
+        // Override the defaults with the user provided props
+        consolidatedStateMachineProps = (0, utils_1.overrideProps)(smDefaults.DefaultStateMachineProps(logGroup), props.stateMachineProps);
+    }
+    // Override the Cloudwatch permissions to make it more fine grained
+    const newStateMachine = new sfn.StateMachine(scope, `StateMachine${(id ?? '')}`, consolidatedStateMachineProps);
+    // If the client did not pass a role we got the default role and will trim the privileges
+    if (!props.stateMachineProps.role) {
+        const role = newStateMachine.node.findChild('Role');
+        const cfnDefaultPolicy = role.node.findChild('DefaultPolicy').node.defaultChild;
+        // Override Cfn Nag warning W12: IAM policy should not allow * resource
+        (0, utils_1.addCfnSuppressRules)(cfnDefaultPolicy, [
+            {
+                id: 'W12',
+                reason: `These are CDK defaults. The 'LogDelivery' actions do not support resource-level authorizations. Any logging is done by State Machine code`
+            }
+        ]);
+    }
+    const createCloudWatchAlarms = (props.createCloudWatchAlarms === undefined || props.createCloudWatchAlarms);
+    const cloudWatchAlarms = createCloudWatchAlarms ? buildStepFunctionCWAlarms(scope, props.cloudWatchAlarmsPrefix, newStateMachine) : undefined;
+    return {
+        stateMachine: newStateMachine,
+        logGroup,
+        cloudWatchAlarms
+    };
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildStepFunctionCWAlarms(scope, id, sm) {
+    // Setup CW Alarms for State Machine
+    const alarms = new Array();
+    const prefix = id ?? "";
+    // Sum of number of executions that failed is >= 1 for 5 minutes, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, `${prefix}ExecutionFailedAlarm`, {
+        metric: sm.metricFailed({
+            statistic: 'Sum',
+            period: cdk.Duration.seconds(300),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Alarm for the number of executions that failed exceeded the threshold of 1. '
+    }));
+    // Sum of number of executions that failed maximum is >= 1 for 5 minute, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, `${prefix}ExecutionThrottledAlarm`, {
+        metric: sm.metricThrottled({
+            statistic: 'Sum',
+            period: cdk.Duration.seconds(300),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Alarm for the number of executions that throttled exceeded the threshold of 1. '
+    }));
+    // Number of executions that aborted maximum is >= 1 for 5 minute, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, `${prefix}ExecutionAbortedAlarm`, {
+        metric: sm.metricAborted({
+            statistic: 'Maximum',
+            period: cdk.Duration.seconds(300),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Alarm for the number of executions that aborted exceeded the threshold of 1. '
+    }));
+    return alarms;
+}
+function CheckStateMachineProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    if ((propsObject.createCloudWatchAlarms === false) && propsObject.cloudWatchAlarmsPrefix) {
+        errorMessages += 'Error - cloudWatchAlarmsPrefix is invalid when createCloudWatchAlarms is false\n';
+        errorFound = true;
+    }
+    if ((propsObject.existingStateMachineObj) &&
+        (propsObject.stateMachineProps ||
+            (propsObject.createCloudWatchAlarms !== undefined) ||
+            propsObject.cloudWatchAlarmsPrefix ||
+            propsObject.logGroupProps)) {
+        errorMessages += 'ERROR - If existingStateMachine is provided, no other state machine props are allowed\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-function-helper.js","sourceRoot":"","sources":["step-function-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\n// Imports\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as cdk from 'aws-cdk-lib';\nimport * as smDefaults from './step-function-defaults';\nimport * as sfn from 'aws-cdk-lib/aws-stepfunctions';\nimport { overrideProps, addCfnSuppressRules, generatePhysicalLogGroupName } from './utils';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport { buildLogGroup } from './cloudwatch-log-group-helper';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\n\n/*\n * the id parameter was added to buildStateMachine() long after the original implementation,\n * this value can be used for the new parameter and ensure behavior is the same.\n * (if we just require an id, the state machine name will be changed and it will be a\n * destructive change)\n */\nexport const idPlaceholder = undefined;\n\nexport interface BuildStateMacineProps {\n  readonly stateMachineProps: sfn.StateMachineProps,\n  readonly logGroupProps?: logs.LogGroupProps,\n  readonly createCloudWatchAlarms?: boolean,\n  readonly cloudWatchAlarmsPrefix?: string\n}\n\nexport interface BuildStateMachineResponse {\n  readonly stateMachine: sfn.StateMachine,\n  readonly logGroup: logs.ILogGroup,\n  readonly cloudWatchAlarms?: cloudwatch.Alarm[]\n}\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n *\n * Builds and returns a StateMachine.\n * @param scope - the construct to which the StateMachine should be attached to.\n * @param stateMachineProps - user-specified properties to override the default properties.\n */\nexport function buildStateMachine(scope: Construct, id: string | undefined, props: BuildStateMacineProps): BuildStateMachineResponse {\n\n  let logGroup: logs.ILogGroup;\n  let consolidatedStateMachineProps;\n\n  // If they sent a logGroup in stateMachineProps\n  if (props.stateMachineProps.logs?.destination) {\n    // In CDK v2.235.0+, logs.destination is ILogGroupRef, but we need ILogGroup\n    // We need to verify it's actually an ILogGroup (has the full interface)\n    const destination = props.stateMachineProps.logs.destination;\n\n    // Type guard: Check if destination has ILogGroup methods\n    if ('addMetricFilter' in destination && 'grantWrite' in destination) {\n      logGroup = destination as logs.ILogGroup;\n    } else {\n      throw new Error('The provided log group destination must be a full ILogGroup (not just ILogGroupRef). ' +\n        'Please provide a LogGroup created with new LogGroup() or LogGroup.fromLogGroupArn().');\n    }\n    consolidatedStateMachineProps = props.stateMachineProps;\n  } else {\n    // Three possibilities\n    // 1) logGroupProps not provided - create logGroupProps with just logGroupName\n    // 2) logGroupProps provided with no logGroupName - override logGroupProps.logGroupName\n    // 3) logGroupProps provided with logGroupName - pass unaltered logGroupProps\n    let consolidatedLogGroupProps = props.logGroupProps;\n\n    if (!consolidatedLogGroupProps) {\n      consolidatedLogGroupProps = {};\n    }\n\n    if (!consolidatedLogGroupProps?.logGroupName) {\n      const logGroupPrefix = '/aws/vendedlogs/states/constructs/';\n      const nameParts: string[] = [\n        cdk.Stack.of(scope).stackName, // Name of the stack\n        id ?? scope.node.id,           // Use the ID from client if provided, otherwise use the construct ID\n        'StateMachineLog'              // Literal string for log group name portion\n      ];\n\n      const logGroupName = generatePhysicalLogGroupName(logGroupPrefix, nameParts);\n      consolidatedLogGroupProps = overrideProps(consolidatedLogGroupProps, { logGroupName });\n    }\n\n    // Create new Cloudwatch log group for Step function State Machine\n    logGroup = buildLogGroup(scope, `StateMachineLogGroup${(id ?? '')}`, consolidatedLogGroupProps);\n\n    // Override the defaults with the user provided props\n    consolidatedStateMachineProps = overrideProps(smDefaults.DefaultStateMachineProps(logGroup), props.stateMachineProps);\n  }\n\n  // Override the Cloudwatch permissions to make it more fine grained\n  const newStateMachine = new sfn.StateMachine(scope, `StateMachine${(id ?? '')}`, consolidatedStateMachineProps);\n\n  // If the client did not pass a role we got the default role and will trim the privileges\n  if (!props.stateMachineProps.role) {\n    const role = newStateMachine.node.findChild('Role') as iam.Role;\n    const cfnDefaultPolicy = role.node.findChild('DefaultPolicy').node.defaultChild as any;\n    // Override Cfn Nag warning W12: IAM policy should not allow * resource\n    addCfnSuppressRules(cfnDefaultPolicy, [\n      {\n        id: 'W12',\n        reason: `These are CDK defaults. The 'LogDelivery' actions do not support resource-level authorizations. Any logging is done by State Machine code`\n      }\n    ]);\n  }\n  const createCloudWatchAlarms: boolean = (props.createCloudWatchAlarms === undefined || props.createCloudWatchAlarms);\n  const cloudWatchAlarms = createCloudWatchAlarms ? buildStepFunctionCWAlarms(scope, props.cloudWatchAlarmsPrefix, newStateMachine) : undefined;\n\n  return {\n    stateMachine: newStateMachine,\n    logGroup,\n    cloudWatchAlarms\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 buildStepFunctionCWAlarms(scope: Construct, id: string | undefined, sm: sfn.StateMachine): cloudwatch.Alarm[] {\n  // Setup CW Alarms for State Machine\n  const alarms: cloudwatch.Alarm[] = new Array();\n  const prefix = id ?? \"\";\n\n  // Sum of number of executions that failed is >= 1 for 5 minutes, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, `${prefix}ExecutionFailedAlarm`, {\n    metric: sm.metricFailed({\n      statistic: 'Sum',\n      period: cdk.Duration.seconds(300),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Alarm for the number of executions that failed exceeded the threshold of 1. '\n  }));\n\n  // Sum of number of executions that failed maximum is >= 1 for 5 minute, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, `${prefix}ExecutionThrottledAlarm`, {\n    metric: sm.metricThrottled({\n      statistic: 'Sum',\n      period: cdk.Duration.seconds(300),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Alarm for the number of executions that throttled exceeded the threshold of 1. '\n  }));\n\n  // Number of executions that aborted maximum is >= 1 for 5 minute, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, `${prefix}ExecutionAbortedAlarm`, {\n    metric: sm.metricAborted({\n      statistic: 'Maximum',\n      period: cdk.Duration.seconds(300),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Alarm for the number of executions that aborted exceeded the threshold of 1. '\n  }));\n\n  return alarms;\n}\n\nexport interface StateMachineProps {\n  readonly stateMachineProps?: sfn.StateMachineProps;\n  readonly existingStateMachineObj?: sfn.StateMachine;\n  readonly createCloudWatchAlarms?: boolean;\n  readonly cloudWatchAlarmsPrefix?: string\n  readonly logGroupProps?: logs.LogGroupProps;\n}\n\nexport function CheckStateMachineProps(propsObject: StateMachineProps | any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if ((propsObject.createCloudWatchAlarms === false) && propsObject.cloudWatchAlarmsPrefix) {\n    errorMessages += 'Error - cloudWatchAlarmsPrefix is invalid when createCloudWatchAlarms is false\\n';\n    errorFound = true;\n  }\n\n  if ((propsObject.existingStateMachineObj) &&\n    (propsObject.stateMachineProps ||\n      (propsObject.createCloudWatchAlarms !== undefined) ||\n      propsObject.cloudWatchAlarmsPrefix ||\n      propsObject.logGroupProps)) {\n\n    errorMessages += 'ERROR - If existingStateMachine is provided, no other state machine props are allowed\\n';\n    errorFound = true;\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n"]}

package/node_modules/@aws-solutions-constructs/core/lib/textract-helper.d.ts

@@ -0,0 +1,63 @@
+/**
+ *  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 s3 from 'aws-cdk-lib/aws-s3';
+import { Construct } from 'constructs';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import * as sns from 'aws-cdk-lib/aws-sns';
+export interface TextractProps {
+    readonly asyncJobs?: boolean;
+    readonly existingSourceBucketObj?: s3.IBucket;
+    readonly sourceBucketProps?: s3.BucketProps;
+    readonly existingDestinationBucketObj?: s3.IBucket;
+    readonly destinationBucketProps?: s3.BucketProps;
+    readonly useSameBucket?: boolean;
+    readonly createCustomerManagedOutputBucket?: boolean;
+    readonly sourceLoggingBucketProps?: s3.BucketProps;
+    readonly destinationLoggingBucketProps?: s3.BucketProps;
+    readonly logSourceS3AccessLogs?: boolean;
+    readonly logDestinationS3AccessLogs?: boolean;
+    readonly sourceBucketEnvironmentVariableName?: string;
+    readonly destinationBucketEnvironmentVariableName?: string;
+    readonly dataAccessRoleArnEnvironmentVariableName?: string;
+    readonly snsNotificationTopicArnEnvironmentVariableName?: string;
+    readonly existingNotificationTopicObj?: sns.Topic;
+    readonly existingNotificationTopicEncryptionKey?: kms.Key;
+    readonly notificationTopicProps?: sns.TopicProps;
+    readonly enableNotificationTopicEncryptionWithCustomerManagedKey?: boolean;
+    readonly notificationTopicEncryptionKey?: kms.Key;
+    readonly notificationTopicEncryptionKeyProps?: kms.KeyProps;
+}
+export interface TextractBucketDetails {
+    readonly bucket?: s3.Bucket;
+    readonly bucketInterface: s3.IBucket;
+    readonly loggingBucket?: s3.Bucket;
+}
+export interface TextractConfiguration {
+    readonly textractRole?: iam.Role;
+    readonly lambdaIamActionsRequired: string[];
+    readonly sourceBucket?: TextractBucketDetails;
+    readonly destinationBucket?: TextractBucketDetails;
+    readonly snsNotificationTopic?: sns.Topic;
+    readonly notificationTopicEncryptionKey?: kms.Key;
+}
+export declare function ConfigureTextractSupport(scope: Construct, id: string, props: TextractProps): TextractConfiguration;
+export declare function CheckTextractProps(props: TextractProps): void;
+export interface TextractSnsProps {
+    readonly notificationTopicProps?: sns.TopicProps;
+    readonly existingNotificationTopicObj?: sns.Topic;
+    readonly existingNotificationTopicObject?: sns.Topic;
+    readonly notificationTopicEncryptionKey?: kms.Key;
+    readonly notificationTopicEncryptionKeyProps?: kms.KeyProps;
+}
+export declare function CheckTextractSnsProps(propsObject: TextractSnsProps | any): void;

package/node_modules/@aws-solutions-constructs/core/lib/textract-helper.js

@@ -0,0 +1,220 @@
+"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.ConfigureTextractSupport = ConfigureTextractSupport;
+exports.CheckTextractProps = CheckTextractProps;
+exports.CheckTextractSnsProps = CheckTextractSnsProps;
+const iam = require("aws-cdk-lib/aws-iam");
+const s3_bucket_helper_1 = require("./s3-bucket-helper");
+const sns_helper_1 = require("./sns-helper");
+const utils_1 = require("./utils");
+const syncPermissions = [
+    'textract:DetectDocumentText',
+    'textract:AnalyzeDocument',
+    'textract:AnalyzeExpense',
+    'textract:AnalyzeID'
+];
+const asyncPermissions = [
+    'textract:StartDocumentTextDetection',
+    'textract:GetDocumentTextDetection',
+    'textract:StartDocumentAnalysis',
+    'textract:GetDocumentAnalysis',
+    'textract:StartExpenseAnalysis',
+    'textract:GetExpenseAnalysis',
+    'textract:StartLendingAnalysis',
+    'textract:GetLendingAnalysis'
+];
+function ConfigureTextractSupport(scope, id, props) {
+    let configuration = {
+        lambdaIamActionsRequired: [...syncPermissions],
+    };
+    if (props.asyncJobs) {
+        const buildTopicResponse = (0, sns_helper_1.buildTopic)(scope, id, {
+            existingTopicObj: props.existingNotificationTopicObj,
+            existingTopicEncryptionKey: props.existingNotificationTopicEncryptionKey,
+            topicProps: props.notificationTopicProps,
+            enableEncryptionWithCustomerManagedKey: props.enableNotificationTopicEncryptionWithCustomerManagedKey,
+            encryptionKey: props.notificationTopicEncryptionKey,
+            encryptionKeyProps: props.notificationTopicEncryptionKeyProps
+        });
+        // Setup notification topic
+        configuration = (0, utils_1.overrideProps)(configuration, {
+            snsNotificationTopic: buildTopicResponse.topic,
+        });
+        if (buildTopicResponse.key) {
+            configuration = (0, utils_1.overrideProps)(configuration, { notificationTopicEncryptionKey: buildTopicResponse.key });
+        }
+        // Setup source S3 Bucket
+        if (props.existingSourceBucketObj) {
+            configuration = (0, utils_1.overrideProps)(configuration, {
+                sourceBucket: {
+                    bucketInterface: props.existingSourceBucketObj
+                }
+            }, false);
+        }
+        else {
+            const buildSourceBucketResponse = (0, s3_bucket_helper_1.buildS3Bucket)(scope, {
+                bucketProps: props.sourceBucketProps,
+                loggingBucketProps: props.sourceLoggingBucketProps,
+                logS3AccessLogs: props.logSourceS3AccessLogs
+            }, `${id}-source-bucket`);
+            configuration = (0, utils_1.overrideProps)(configuration, {
+                sourceBucket: {
+                    bucket: buildSourceBucketResponse.bucket,
+                    loggingBucket: buildSourceBucketResponse.loggingBucket,
+                    bucketInterface: buildSourceBucketResponse.bucket,
+                }
+            }, false);
+        }
+        if (props.createCustomerManagedOutputBucket !== false) {
+            // Setup destination S3 Bucket
+            if (props.useSameBucket) {
+                configuration = (0, utils_1.overrideProps)(configuration, {
+                    destinationBucket: {
+                        bucketInterface: configuration.sourceBucket?.bucketInterface,
+                        bucket: configuration.sourceBucket?.bucket,
+                        loggingBucket: configuration.sourceBucket?.loggingBucket,
+                    }
+                }, false);
+            }
+            else {
+                if (props.existingDestinationBucketObj) {
+                    configuration = (0, utils_1.overrideProps)(configuration, {
+                        destinationBucket: {
+                            bucketInterface: props.existingDestinationBucketObj
+                        }
+                    }, false);
+                }
+                else {
+                    const buildDestinationBucketResponse = (0, s3_bucket_helper_1.buildS3Bucket)(scope, {
+                        bucketProps: props.destinationBucketProps,
+                        loggingBucketProps: props.destinationLoggingBucketProps,
+                        logS3AccessLogs: props.logDestinationS3AccessLogs
+                    }, `${id}-destination-bucket`);
+                    configuration = (0, utils_1.overrideProps)(configuration, {
+                        destinationBucket: {
+                            bucket: buildDestinationBucketResponse.bucket,
+                            loggingBucket: buildDestinationBucketResponse.loggingBucket,
+                            bucketInterface: buildDestinationBucketResponse.bucket,
+                        }
+                    }, false);
+                }
+            }
+        }
+        // Set up role that is sent to the Textract service
+        const textractServiceRole = new iam.Role(scope, `${id}-textract-service-role`, {
+            assumedBy: new iam.ServicePrincipal('textract.amazonaws.com'),
+        });
+        configuration.snsNotificationTopic.grantPublish(textractServiceRole);
+        configuration = (0, utils_1.overrideProps)(configuration, {
+            textractRole: textractServiceRole
+        }, false);
+        // Give the Lambda function additional permissions
+        asyncPermissions.forEach((permission) => {
+            configuration.lambdaIamActionsRequired.push(permission);
+        });
+    }
+    return configuration;
+}
+function CheckTextractProps(props) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (props.asyncJobs) {
+        // Check source bucket props
+        const sourceS3Props = {
+            existingBucketObj: props.existingSourceBucketObj,
+            bucketProps: props.sourceBucketProps,
+            loggingBucketProps: props.sourceLoggingBucketProps,
+            logS3AccessLogs: props.logSourceS3AccessLogs
+        };
+        (0, s3_bucket_helper_1.CheckS3Props)(sourceS3Props);
+        // Check destination bucket props (only if not using same bucket)
+        if (!props.useSameBucket) {
+            const destinationS3Props = {
+                existingBucketObj: props.existingDestinationBucketObj,
+                bucketProps: props.destinationBucketProps,
+                loggingBucketProps: props.destinationLoggingBucketProps,
+                logS3AccessLogs: props.logDestinationS3AccessLogs
+            };
+            (0, s3_bucket_helper_1.CheckS3Props)(destinationS3Props);
+        }
+        // Check SNS topic props
+        CheckTextractSnsProps(props);
+    }
+    // If asyncJobs is false, no S3 bucket props should be provided
+    if (!props.asyncJobs) {
+        if (props.existingSourceBucketObj || props.sourceBucketProps ||
+            props.existingDestinationBucketObj || props.destinationBucketProps ||
+            props.sourceLoggingBucketProps || props.destinationLoggingBucketProps ||
+            props.logSourceS3AccessLogs !== undefined || props.logDestinationS3AccessLogs !== undefined ||
+            props.sourceBucketEnvironmentVariableName || props.destinationBucketEnvironmentVariableName ||
+            props.dataAccessRoleArnEnvironmentVariableName || props.useSameBucket) {
+            errorMessages += 'S3 bucket properties can only be provided when asyncJobs is true\n';
+            errorFound = true;
+        }
+        // Check SNS topic props separately for clearer error message
+        if (props.existingNotificationTopicObj || props.notificationTopicProps || props.existingNotificationTopicEncryptionKey ||
+            props.enableNotificationTopicEncryptionWithCustomerManagedKey !== undefined || props.notificationTopicEncryptionKey ||
+            props.notificationTopicEncryptionKeyProps) {
+            errorMessages += 'SNS topic properties can only be provided when asyncJobs is true';
+            errorFound = true;
+        }
+    }
+    // If useSameBucket is true, no destination bucket props should be provided
+    if (props.useSameBucket) {
+        if (props.existingDestinationBucketObj || props.destinationBucketProps ||
+            props.destinationLoggingBucketProps || props.logDestinationS3AccessLogs !== undefined) {
+            errorMessages += 'Destination bucket properties cannot be provided when useSameBucket is true\n';
+            errorFound = true;
+        }
+    }
+    // If createCustomerManagedOutputBucket is explicitly false, no output bucket properties should be provided
+    if (props.createCustomerManagedOutputBucket === false) {
+        if (props.existingDestinationBucketObj || props.destinationBucketProps ||
+            props.destinationLoggingBucketProps || props.logDestinationS3AccessLogs !== undefined ||
+            props.useSameBucket) {
+            errorMessages += 'Output bucket properties cannot be provided when createCustomerManagedOutputBucket is false';
+            errorFound = true;
+        }
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+function CheckTextractSnsProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    // FargateToSns used TopicObject instead of TopicObj - to fix would be a breaking change, so we
+    // must look for both here.
+    if (propsObject.notificationTopicProps && (propsObject.existingNotificationTopicObj || propsObject.existingNotificationTopicObject)) {
+        errorMessages += 'Error - Either provide notificationTopicProps or existingNotificationTopicObj, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.notificationTopicProps?.masterKey && propsObject.notificationTopicEncryptionKey) {
+        errorMessages += 'Error - Either provide notificationTopicProps.masterKey or notificationTopicEncryptionKey, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.notificationTopicProps?.masterKey && propsObject.notificationTopicEncryptionKeyProps) {
+        errorMessages += 'Error - Either provide notificationTopicProps.masterKey or notificationTopicEncryptionKeyProps, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.notificationTopicEncryptionKey && propsObject.notificationTopicEncryptionKeyProps) {
+        errorMessages += 'Error - Either provide notificationTopicEncryptionKey or notificationTopicEncryptionKeyProps, but not both.\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textract-helper.js","sourceRoot":"","sources":["textract-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport { Construct } from 'constructs';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { CheckS3Props, buildS3Bucket } from './s3-bucket-helper';\nimport { buildTopic } from './sns-helper';\nimport { overrideProps } from './utils';\nimport * as sns from 'aws-cdk-lib/aws-sns';\n\nexport interface TextractProps {\n  readonly asyncJobs?: boolean;\n  readonly existingSourceBucketObj?: s3.IBucket;\n  readonly sourceBucketProps?: s3.BucketProps;\n  readonly existingDestinationBucketObj?: s3.IBucket;\n  readonly destinationBucketProps?: s3.BucketProps;\n  readonly useSameBucket?: boolean;\n  readonly createCustomerManagedOutputBucket?: boolean;\n  readonly sourceLoggingBucketProps?: s3.BucketProps;\n  readonly destinationLoggingBucketProps?: s3.BucketProps;\n  readonly logSourceS3AccessLogs?: boolean;\n  readonly logDestinationS3AccessLogs?: boolean;\n  readonly sourceBucketEnvironmentVariableName?: string;\n  readonly destinationBucketEnvironmentVariableName?: string;\n  readonly dataAccessRoleArnEnvironmentVariableName?: string;\n  readonly snsNotificationTopicArnEnvironmentVariableName?: string;\n  readonly existingNotificationTopicObj?: sns.Topic;\n  readonly existingNotificationTopicEncryptionKey?: kms.Key;\n  readonly notificationTopicProps?: sns.TopicProps;\n  readonly enableNotificationTopicEncryptionWithCustomerManagedKey?: boolean;\n  readonly notificationTopicEncryptionKey?: kms.Key;\n  readonly notificationTopicEncryptionKeyProps?: kms.KeyProps;\n}\n\nexport interface TextractBucketDetails {\n  readonly bucket?: s3.Bucket,\n  readonly bucketInterface: s3.IBucket,\n  readonly loggingBucket?: s3.Bucket\n}\n\nexport interface TextractConfiguration {\n  readonly textractRole?: iam.Role,\n  readonly lambdaIamActionsRequired: string[],\n  readonly sourceBucket?: TextractBucketDetails,\n  readonly destinationBucket?: TextractBucketDetails,\n  readonly snsNotificationTopic?: sns.Topic,\n  readonly notificationTopicEncryptionKey?: kms.Key,\n}\n\nconst syncPermissions = [\n  'textract:DetectDocumentText',\n  'textract:AnalyzeDocument',\n  'textract:AnalyzeExpense',\n  'textract:AnalyzeID'\n];\n\nconst asyncPermissions = [\n  'textract:StartDocumentTextDetection',\n  'textract:GetDocumentTextDetection',\n  'textract:StartDocumentAnalysis',\n  'textract:GetDocumentAnalysis',\n  'textract:StartExpenseAnalysis',\n  'textract:GetExpenseAnalysis',\n  'textract:StartLendingAnalysis',\n  'textract:GetLendingAnalysis'\n];\n\nexport function ConfigureTextractSupport(scope: Construct, id: string, props: TextractProps): TextractConfiguration {\n\n  let configuration: TextractConfiguration = {\n    lambdaIamActionsRequired: [...syncPermissions],\n  };\n\n  if (props.asyncJobs) {\n    const buildTopicResponse = buildTopic(scope, id, {\n      existingTopicObj: props.existingNotificationTopicObj,\n      existingTopicEncryptionKey: props.existingNotificationTopicEncryptionKey,\n      topicProps: props.notificationTopicProps,\n      enableEncryptionWithCustomerManagedKey: props.enableNotificationTopicEncryptionWithCustomerManagedKey,\n      encryptionKey: props.notificationTopicEncryptionKey,\n      encryptionKeyProps: props.notificationTopicEncryptionKeyProps\n    });\n    // Setup notification topic\n    configuration = overrideProps(configuration, {\n      snsNotificationTopic: buildTopicResponse.topic,\n    });\n    if (buildTopicResponse.key) {\n      configuration = overrideProps(configuration, { notificationTopicEncryptionKey: buildTopicResponse.key });\n    }\n\n    // Setup source S3 Bucket\n    if (props.existingSourceBucketObj) {\n      configuration = overrideProps(configuration, {\n        sourceBucket: {\n          bucketInterface: props.existingSourceBucketObj\n        }\n      }, false);\n    } else {\n      const buildSourceBucketResponse = buildS3Bucket(scope, {\n        bucketProps: props.sourceBucketProps,\n        loggingBucketProps: props.sourceLoggingBucketProps,\n        logS3AccessLogs: props.logSourceS3AccessLogs\n      }, `${id}-source-bucket`);\n      configuration = overrideProps(configuration, {\n        sourceBucket: {\n          bucket: buildSourceBucketResponse.bucket,\n          loggingBucket: buildSourceBucketResponse.loggingBucket,\n          bucketInterface: buildSourceBucketResponse.bucket,\n        }\n      }, false);\n    }\n\n    if (props.createCustomerManagedOutputBucket !== false) {\n      // Setup destination S3 Bucket\n      if (props.useSameBucket) {\n        configuration = overrideProps(configuration, {\n          destinationBucket: {\n            bucketInterface: configuration.sourceBucket?.bucketInterface,\n            bucket: configuration.sourceBucket?.bucket,\n            loggingBucket: configuration.sourceBucket?.loggingBucket,\n          }\n        }, false);\n      } else {\n        if (props.existingDestinationBucketObj) {\n          configuration = overrideProps(configuration, {\n            destinationBucket: {\n              bucketInterface: props.existingDestinationBucketObj\n            }\n          }, false);\n        } else {\n          const buildDestinationBucketResponse = buildS3Bucket(scope, {\n            bucketProps: props.destinationBucketProps,\n            loggingBucketProps: props.destinationLoggingBucketProps,\n            logS3AccessLogs: props.logDestinationS3AccessLogs\n          }, `${id}-destination-bucket`);\n          configuration = overrideProps(configuration, {\n            destinationBucket: {\n              bucket: buildDestinationBucketResponse.bucket,\n              loggingBucket: buildDestinationBucketResponse.loggingBucket,\n              bucketInterface: buildDestinationBucketResponse.bucket,\n            }\n          }, false);\n        }\n      }\n    }\n\n    // Set up role that is sent to the Textract service\n    const textractServiceRole = new iam.Role(scope, `${id}-textract-service-role`, {\n      assumedBy: new iam.ServicePrincipal('textract.amazonaws.com'),\n    });\n    configuration.snsNotificationTopic!.grantPublish(textractServiceRole);\n    configuration = overrideProps(configuration, {\n      textractRole: textractServiceRole\n    }, false);\n\n    // Give the Lambda function additional permissions\n    asyncPermissions.forEach((permission) => {\n      configuration.lambdaIamActionsRequired.push(permission);\n    });\n\n  }\n  return configuration;\n}\n\nexport function CheckTextractProps(props: TextractProps): void {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (props.asyncJobs) {\n\n    // Check source bucket props\n    const sourceS3Props = {\n      existingBucketObj: props.existingSourceBucketObj,\n      bucketProps: props.sourceBucketProps,\n      loggingBucketProps: props.sourceLoggingBucketProps,\n      logS3AccessLogs: props.logSourceS3AccessLogs\n    };\n    CheckS3Props(sourceS3Props);\n\n    // Check destination bucket props (only if not using same bucket)\n    if (!props.useSameBucket) {\n      const destinationS3Props = {\n        existingBucketObj: props.existingDestinationBucketObj,\n        bucketProps: props.destinationBucketProps,\n        loggingBucketProps: props.destinationLoggingBucketProps,\n        logS3AccessLogs: props.logDestinationS3AccessLogs\n      };\n      CheckS3Props(destinationS3Props);\n    }\n\n    // Check SNS topic props\n    CheckTextractSnsProps(props);\n  }\n\n  // If asyncJobs is false, no S3 bucket props should be provided\n  if (!props.asyncJobs) {\n    if (props.existingSourceBucketObj || props.sourceBucketProps ||\n      props.existingDestinationBucketObj || props.destinationBucketProps ||\n      props.sourceLoggingBucketProps || props.destinationLoggingBucketProps ||\n      props.logSourceS3AccessLogs !== undefined || props.logDestinationS3AccessLogs !== undefined ||\n      props.sourceBucketEnvironmentVariableName || props.destinationBucketEnvironmentVariableName ||\n      props.dataAccessRoleArnEnvironmentVariableName || props.useSameBucket) {\n      errorMessages += 'S3 bucket properties can only be provided when asyncJobs is true\\n';\n      errorFound = true;\n    }\n\n    // Check SNS topic props separately for clearer error message\n    if (props.existingNotificationTopicObj || props.notificationTopicProps || props.existingNotificationTopicEncryptionKey ||\n      props.enableNotificationTopicEncryptionWithCustomerManagedKey !== undefined || props.notificationTopicEncryptionKey ||\n      props.notificationTopicEncryptionKeyProps) {\n      errorMessages += 'SNS topic properties can only be provided when asyncJobs is true';\n      errorFound = true;\n    }\n  }\n\n  // If useSameBucket is true, no destination bucket props should be provided\n  if (props.useSameBucket) {\n    if (props.existingDestinationBucketObj || props.destinationBucketProps ||\n      props.destinationLoggingBucketProps || props.logDestinationS3AccessLogs !== undefined) {\n      errorMessages += 'Destination bucket properties cannot be provided when useSameBucket is true\\n';\n      errorFound = true;\n    }\n  }\n\n  // If createCustomerManagedOutputBucket is explicitly false, no output bucket properties should be provided\n  if (props.createCustomerManagedOutputBucket === false) {\n    if (props.existingDestinationBucketObj || props.destinationBucketProps ||\n      props.destinationLoggingBucketProps || props.logDestinationS3AccessLogs !== undefined ||\n      props.useSameBucket) {\n      errorMessages += 'Output bucket properties cannot be provided when createCustomerManagedOutputBucket is false';\n      errorFound = true;\n    }\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n\n/*\n * Because the notification topic is a secondary resource\n * for textract configurations, the prop names are different\n * than when SNS is primary resource. CheckTextractSnsProps() is\n * a clone of the CheckSnsProps() in sns-helper.ts using the\n * Textract notification topic specific names. This has a risk of\n * getting out of sync going forward - but this seemed a better\n * solution than CheckSnsProps throwing error messages with the\n * wrong property names.\n */\nexport interface TextractSnsProps {\n  readonly notificationTopicProps?: sns.TopicProps,\n  readonly existingNotificationTopicObj?: sns.Topic,\n  readonly existingNotificationTopicObject?: sns.Topic,\n  readonly notificationTopicEncryptionKey?: kms.Key,\n  readonly notificationTopicEncryptionKeyProps?: kms.KeyProps\n}\n\nexport function CheckTextractSnsProps(propsObject: TextractSnsProps | any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  // FargateToSns used TopicObject instead of TopicObj - to fix would be a breaking change, so we\n  // must look for both here.\n  if (propsObject.notificationTopicProps && (propsObject.existingNotificationTopicObj || propsObject.existingNotificationTopicObject)) {\n    errorMessages += 'Error - Either provide notificationTopicProps or existingNotificationTopicObj, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.notificationTopicProps?.masterKey && propsObject.notificationTopicEncryptionKey) {\n    errorMessages += 'Error - Either provide notificationTopicProps.masterKey or notificationTopicEncryptionKey, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.notificationTopicProps?.masterKey && propsObject.notificationTopicEncryptionKeyProps) {\n    errorMessages += 'Error - Either provide notificationTopicProps.masterKey or notificationTopicEncryptionKeyProps, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.notificationTopicEncryptionKey && propsObject.notificationTopicEncryptionKeyProps) {\n    errorMessages += 'Error - Either provide notificationTopicEncryptionKey or notificationTopicEncryptionKeyProps, 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/core/lib/translate-helper.d.ts

@@ -0,0 +1,43 @@
+/**
+ *  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 s3 from 'aws-cdk-lib/aws-s3';
+import { Construct } from 'constructs';
+import * as iam from 'aws-cdk-lib/aws-iam';
+export interface TranslateProps {
+    readonly asyncJobs?: boolean;
+    readonly existingSourceBucketObj?: s3.IBucket;
+    readonly sourceBucketProps?: s3.BucketProps;
+    readonly existingDestinationBucketObj?: s3.IBucket;
+    readonly destinationBucketProps?: s3.BucketProps;
+    readonly useSameBucket?: boolean;
+    readonly sourceLoggingBucketProps?: s3.BucketProps;
+    readonly destinationLoggingBucketProps?: s3.BucketProps;
+    readonly logSourceS3AccessLogs?: boolean;
+    readonly logDestinationS3AccessLogs?: boolean;
+    readonly sourceBucketEnvironmentVariableName?: string;
+    readonly destinationBucketEnvironmentVariableName?: string;
+    readonly dataAccessRoleArnEnvironmentVariableName?: string;
+}
+export interface TranslateConfiguration {
+    readonly translateRole?: iam.Role;
+    readonly lambdaIamActionsRequired: string[];
+    readonly sourceBucket?: BucketDetails;
+    readonly destinationBucket?: BucketDetails;
+}
+export interface BucketDetails {
+    readonly bucket?: s3.Bucket;
+    readonly bucketInterface: s3.IBucket;
+    readonly loggingBucket?: s3.Bucket;
+}
+export declare function ConfigureTranslateSupport(scope: Construct, id: string, props: TranslateProps): TranslateConfiguration;
+export declare function CheckTranslateProps(props: TranslateProps): void;