@gemeentenijmegen/webapp 1.0.1 → 1.1.0

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

@@ -0,0 +1,73 @@
+/**
+ *  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 sns from 'aws-cdk-lib/aws-sns';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import { Construct } from 'constructs';
+export interface BuildTopicProps {
+    /**
+     * Existing SNS topic to be used instead of the default topic. Providing both this and `topicProps` will cause an error.
+     * If the SNS Topic is encrypted with a Customer-Managed managed KMS key, the key must be specified in the
+     * `existingTopicEncryptionKey` property.
+     *
+     * @default - Default props are used
+     */
+    readonly existingTopicObj?: sns.Topic;
+    /**
+     * If an existing topic is provided in the `existingTopicObj` property, and that topic is encrypted with a customer managed KMS key,
+     * this property also needs to be set with same CMK.
+     *
+     * @default - None
+     */
+    readonly existingTopicEncryptionKey?: kms.Key;
+    /**
+     * Optional user provided props to override the default props for the SNS topic.
+     *
+     * @default - Default props are used.
+     */
+    readonly topicProps?: sns.TopicProps;
+    /**
+     * If no key is provided, this flag determines whether the topic is encrypted with a new CMK or an AWS managed key.
+     * This flag is ignored if any of the following are defined: topicProps.masterKey, encryptionKey or encryptionKeyProps.
+     *
+     * @default - False if topicProps.masterKey, encryptionKey, and encryptionKeyProps are all undefined.
+     */
+    readonly enableEncryptionWithCustomerManagedKey?: boolean;
+    /**
+     * An optional, imported encryption key to encrypt the SNS topic with.
+     *
+     * @default - None
+     */
+    readonly encryptionKey?: kms.Key;
+    /**
+     * Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SNS topic with.
+     *
+     * @default - None
+     */
+    readonly encryptionKeyProps?: kms.KeyProps;
+}
+export interface BuildTopicResponse {
+    readonly topic: sns.Topic;
+    readonly key?: kms.Key;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildTopic(scope: Construct, id: string, props: BuildTopicProps): BuildTopicResponse;
+export interface SnsProps {
+    readonly topicProps?: sns.TopicProps;
+    readonly existingTopicObj?: sns.Topic;
+    readonly existingTopicObject?: sns.Topic;
+    readonly encryptionKey?: kms.Key;
+    readonly encryptionKeyProps?: kms.KeyProps;
+}
+export declare function CheckSnsProps(propsObject: SnsProps | any): void;

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

@@ -0,0 +1,139 @@
+"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.CheckSnsProps = exports.buildTopic = 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 sns = require("aws-cdk-lib/aws-sns");
+const kms = require("aws-cdk-lib/aws-kms");
+const sns_defaults_1 = require("./sns-defaults");
+const kms_helper_1 = require("./kms-helper");
+const utils_1 = require("./utils");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+function applySecureTopicPolicy(topic) {
+    // Apply topic policy to enforce only the topic owner can publish and subscribe to this topic
+    topic.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+        sid: 'TopicOwnerOnlyAccess',
+        resources: [
+            `${topic.topicArn}`
+        ],
+        actions: [
+            "SNS:Publish",
+            "SNS:RemovePermission",
+            "SNS:SetTopicAttributes",
+            "SNS:DeleteTopic",
+            "SNS:ListSubscriptionsByTopic",
+            "SNS:GetTopicAttributes",
+            "SNS:Receive",
+            "SNS:AddPermission",
+            "SNS:Subscribe"
+        ],
+        principals: [new aws_iam_1.AccountPrincipal(aws_cdk_lib_1.Stack.of(topic).account)],
+        effect: aws_iam_1.Effect.ALLOW,
+        conditions: {
+            StringEquals: {
+                "AWS:SourceOwner": aws_cdk_lib_1.Stack.of(topic).account
+            }
+        }
+    }));
+    // Apply Topic policy to enforce encryption of data in transit
+    topic.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+        sid: 'HttpsOnly',
+        resources: [
+            `${topic.topicArn}`
+        ],
+        actions: [
+            "SNS:Publish",
+            "SNS:RemovePermission",
+            "SNS:SetTopicAttributes",
+            "SNS:DeleteTopic",
+            "SNS:ListSubscriptionsByTopic",
+            "SNS:GetTopicAttributes",
+            "SNS:Receive",
+            "SNS:AddPermission",
+            "SNS:Subscribe"
+        ],
+        principals: [new aws_iam_1.AnyPrincipal()],
+        effect: aws_iam_1.Effect.DENY,
+        conditions: {
+            Bool: {
+                'aws:SecureTransport': 'false'
+            }
+        }
+    }));
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildTopic(scope, id, props) {
+    if (!props.existingTopicObj) {
+        // Setup the topic properties
+        const snsTopicProps = (0, utils_1.consolidateProps)(sns_defaults_1.DefaultSnsTopicProps, props.topicProps);
+        // Set encryption properties
+        if (props.topicProps?.masterKey) {
+            snsTopicProps.masterKey = props.topicProps?.masterKey;
+        }
+        else if (props.encryptionKey) {
+            snsTopicProps.masterKey = props.encryptionKey;
+        }
+        else if (props.encryptionKeyProps || props.enableEncryptionWithCustomerManagedKey === true) {
+            snsTopicProps.masterKey = (0, kms_helper_1.buildEncryptionKey)(scope, id, props.encryptionKeyProps);
+        }
+        else {
+            snsTopicProps.masterKey = kms.Alias.fromAliasName(scope, 'aws-managed-key', 'alias/aws/sns');
+        }
+        // Create the SNS Topic
+        // NOSONAR (typescript:S6327) - The masterKey is set in the if statement above, SONAR is
+        // not catching it. Behavior is confirmed in the
+        // 'Test deployment with no properties using AWS Managed KMS Key' unit test
+        const topic = new sns.Topic(scope, 'SnsTopic', snsTopicProps); // NOSONAR
+        applySecureTopicPolicy(topic);
+        return { topic, key: snsTopicProps.masterKey };
+    }
+    else {
+        return { topic: props.existingTopicObj, key: props.existingTopicEncryptionKey };
+    }
+}
+exports.buildTopic = buildTopic;
+function CheckSnsProps(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.topicProps && (propsObject.existingTopicObj || propsObject.existingTopicObject)) {
+        errorMessages += 'Error - Either provide topicProps or existingTopicObj, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.topicProps?.masterKey && propsObject.encryptionKey) {
+        errorMessages += 'Error - Either provide topicProps.masterKey or encryptionKey, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.topicProps?.masterKey && propsObject.encryptionKeyProps) {
+        errorMessages += 'Error - Either provide topicProps.masterKey or encryptionKeyProps, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.encryptionKey && propsObject.encryptionKeyProps) {
+        errorMessages += 'Error - Either provide encryptionKey or encryptionKeyProps, but not both.\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+exports.CheckSnsProps = CheckSnsProps;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sns-helper.js","sourceRoot":"","sources":["sns-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 sns from 'aws-cdk-lib/aws-sns';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { DefaultSnsTopicProps } from './sns-defaults';\nimport { buildEncryptionKey } from './kms-helper';\nimport { consolidateProps } from './utils';\nimport { PolicyStatement, AnyPrincipal, Effect, AccountPrincipal } from 'aws-cdk-lib/aws-iam';\nimport { Stack } from 'aws-cdk-lib';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\n\nexport interface BuildTopicProps {\n    /**\n     * Existing SNS topic to be used instead of the default topic. Providing both this and `topicProps` will cause an error.\n     * If the SNS Topic is encrypted with a Customer-Managed managed KMS key, the key must be specified in the\n     * `existingTopicEncryptionKey` property.\n     *\n     * @default - Default props are used\n     */\n    readonly existingTopicObj?: sns.Topic;\n     /**\n      * If an existing topic is provided in the `existingTopicObj` property, and that topic is encrypted with a customer managed KMS key,\n      * this property also needs to be set with same CMK.\n      *\n      * @default - None\n      */\n    readonly existingTopicEncryptionKey?: kms.Key;\n    /**\n     * Optional user provided props to override the default props for the SNS topic.\n     *\n     * @default - Default props are used.\n     */\n    readonly topicProps?: sns.TopicProps;\n    /**\n     * If no key is provided, this flag determines whether the topic is encrypted with a new CMK or an AWS managed key.\n     * This flag is ignored if any of the following are defined: topicProps.masterKey, encryptionKey or encryptionKeyProps.\n     *\n     * @default - False if topicProps.masterKey, encryptionKey, and encryptionKeyProps are all undefined.\n     */\n    readonly enableEncryptionWithCustomerManagedKey?: boolean;\n    /**\n     * An optional, imported encryption key to encrypt the SNS topic with.\n     *\n     * @default - None\n     */\n    readonly encryptionKey?: kms.Key;\n    /**\n     * Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SNS topic with.\n     *\n     * @default - None\n     */\n    readonly encryptionKeyProps?: kms.KeyProps;\n}\n\nfunction applySecureTopicPolicy(topic: sns.Topic): void {\n\n  // Apply topic policy to enforce only the topic owner can publish and subscribe to this topic\n  topic.addToResourcePolicy(\n    new PolicyStatement({\n      sid: 'TopicOwnerOnlyAccess',\n      resources: [\n        `${topic.topicArn}`\n      ],\n      actions: [\n        \"SNS:Publish\",\n        \"SNS:RemovePermission\",\n        \"SNS:SetTopicAttributes\",\n        \"SNS:DeleteTopic\",\n        \"SNS:ListSubscriptionsByTopic\",\n        \"SNS:GetTopicAttributes\",\n        \"SNS:Receive\",\n        \"SNS:AddPermission\",\n        \"SNS:Subscribe\"\n      ],\n      principals: [new AccountPrincipal(Stack.of(topic).account)],\n      effect: Effect.ALLOW,\n      conditions:\n            {\n              StringEquals: {\n                \"AWS:SourceOwner\": Stack.of(topic).account\n              }\n            }\n    })\n  );\n\n  // Apply Topic policy to enforce encryption of data in transit\n  topic.addToResourcePolicy(\n    new PolicyStatement({\n      sid: 'HttpsOnly',\n      resources: [\n        `${topic.topicArn}`\n      ],\n      actions: [\n        \"SNS:Publish\",\n        \"SNS:RemovePermission\",\n        \"SNS:SetTopicAttributes\",\n        \"SNS:DeleteTopic\",\n        \"SNS:ListSubscriptionsByTopic\",\n        \"SNS:GetTopicAttributes\",\n        \"SNS:Receive\",\n        \"SNS:AddPermission\",\n        \"SNS:Subscribe\"\n      ],\n      principals: [new AnyPrincipal()],\n      effect: Effect.DENY,\n      conditions:\n            {\n              Bool: {\n                'aws:SecureTransport': 'false'\n              }\n            }\n    })\n  );\n}\n\nexport interface BuildTopicResponse {\n  readonly topic: sns.Topic,\n  readonly key?: kms.Key\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildTopic(scope: Construct, id: string, props: BuildTopicProps): BuildTopicResponse {\n  if (!props.existingTopicObj) {\n    // Setup the topic properties\n    const snsTopicProps = consolidateProps(DefaultSnsTopicProps, props.topicProps);\n\n    // Set encryption properties\n    if (props.topicProps?.masterKey) {\n      snsTopicProps.masterKey = props.topicProps?.masterKey;\n    } else if (props.encryptionKey) {\n      snsTopicProps.masterKey = props.encryptionKey;\n    } else if (props.encryptionKeyProps || props.enableEncryptionWithCustomerManagedKey === true) {\n      snsTopicProps.masterKey = buildEncryptionKey(scope, id, props.encryptionKeyProps);\n    } else {\n      snsTopicProps.masterKey = kms.Alias.fromAliasName(scope, 'aws-managed-key', 'alias/aws/sns');\n    }\n\n    // Create the SNS Topic\n    // NOSONAR (typescript:S6327) - The masterKey is set in the if statement above, SONAR is\n    // not catching it. Behavior is confirmed in the\n    // 'Test deployment with no properties using AWS Managed KMS Key' unit test\n    const topic: sns.Topic = new sns.Topic(scope, 'SnsTopic', snsTopicProps); // NOSONAR\n\n    applySecureTopicPolicy(topic);\n\n    return { topic, key: snsTopicProps.masterKey };\n  } else {\n    return { topic: props.existingTopicObj, key: props.existingTopicEncryptionKey };\n  }\n}\n\nexport interface SnsProps {\n  readonly topicProps?: sns.TopicProps,\n  readonly existingTopicObj?: sns.Topic,\n  readonly existingTopicObject?: sns.Topic,\n  readonly encryptionKey?: kms.Key,\n  readonly encryptionKeyProps?: kms.KeyProps\n}\n\nexport function CheckSnsProps(propsObject: SnsProps | 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.topicProps && (propsObject.existingTopicObj || propsObject.existingTopicObject)) {\n    errorMessages += 'Error - Either provide topicProps or existingTopicObj, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.topicProps?.masterKey && propsObject.encryptionKey) {\n    errorMessages += 'Error - Either provide topicProps.masterKey or encryptionKey, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.topicProps?.masterKey && propsObject.encryptionKeyProps) {\n    errorMessages += 'Error - Either provide topicProps.masterKey or encryptionKeyProps, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.encryptionKey && propsObject.encryptionKeyProps) {\n    errorMessages += 'Error - Either provide encryptionKey or encryptionKeyProps, 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/sqs-helper.d.ts

@@ -0,0 +1,132 @@
+/**
+ *  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 sqs from 'aws-cdk-lib/aws-sqs';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import { Construct } from 'constructs';
+export interface BuildQueueProps {
+    /**
+     * Existing instance of SQS queue object, providing both this and queueProps will cause an error.
+     *
+     * @default - None.
+     */
+    readonly existingQueueObj?: sqs.Queue;
+    /**
+     * Optional user provided props to override the default props for the primary queue.
+     *
+     * @default - Default props are used.
+     */
+    readonly queueProps?: sqs.QueueProps;
+    /**
+     * Optional props required by the construct that overide both the default and client supplied values
+     *
+     * @default - none
+     */
+    readonly constructQueueProps?: sqs.QueueProps;
+    /**
+     * If no key is provided, this flag determines whether the queue is encrypted with a new CMK or an AWS managed key.
+     * This flag is ignored if any of the following are defined: queueProps.encryptionMasterKey, encryptionKey or encryptionKeyProps.
+     *
+     * @default - False if queueProps.encryptionMasterKey, encryptionKey, and encryptionKeyProps are all undefined.
+     */
+    readonly enableEncryptionWithCustomerManagedKey?: boolean;
+    /**
+     * An optional, imported encryption key to encrypt the SQS Queue with.
+     *
+     * @default - None
+     */
+    readonly encryptionKey?: kms.Key;
+    /**
+     * Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SQS Queue with.
+     *
+     * @default - None
+     */
+    readonly encryptionKeyProps?: kms.KeyProps;
+    /**
+     * Whether to deploy a secondary queue to be used as a dead letter queue.
+     *
+     * @default - true
+     */
+    readonly deployDeadLetterQueue?: boolean;
+    /**
+     * Optional user provided properties for the dead letter queue
+     *
+     * @default - Default props are used
+     */
+    readonly deadLetterQueueProps?: sqs.QueueProps;
+    /**
+     * Optional props required by the construct that overide both the default and client supplied values
+     *
+     * @default - none
+     */
+    readonly constructDeadLetterQueueProps?: sqs.QueueProps;
+    /**
+     * The number of times a message can be unsuccessfully dequeued before being moved to the dead letter queue.
+     *
+     * @default - Default props are used
+     */
+    readonly maxReceiveCount?: number;
+}
+export interface BuildQueueResponse {
+    readonly queue: sqs.Queue;
+    readonly key?: kms.IKey;
+    readonly dlq?: sqs.DeadLetterQueue;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildQueue(scope: Construct, id: string, props: BuildQueueProps): BuildQueueResponse;
+export interface BuildDeadLetterQueueProps {
+    /**
+     * Existing instance of SQS queue object, providing both this and queueProps will cause an error.
+     *
+     * @default - None.
+     */
+    readonly existingQueueObj?: sqs.Queue;
+    /**
+     * Whether to deploy a secondary queue to be used as a dead letter queue.
+     *
+     * @default - required field.
+     */
+    readonly deployDeadLetterQueue?: boolean;
+    /**
+     * Optional user provided properties for the dead letter queue
+     *
+     * @default - Default props are used
+     */
+    readonly deadLetterQueueProps?: sqs.QueueProps;
+    /**
+     * Optional Props that override default and client props
+     *
+     * @default - Default props are used
+     */
+    readonly constructDeadLetterQueueProps?: sqs.QueueProps;
+    /**
+     * The number of times a message can be unsuccessfully dequeued before being moved to the dead letter queue.
+     *
+     * @default - Default props are used
+     */
+    readonly maxReceiveCount?: number;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildDeadLetterQueue(scope: Construct, id: string, props: BuildDeadLetterQueueProps): sqs.DeadLetterQueue | undefined;
+export interface SqsProps {
+    readonly existingQueueObj?: sqs.Queue;
+    readonly queueProps?: sqs.QueueProps;
+    readonly deployDeadLetterQueue?: boolean;
+    readonly deadLetterQueueProps?: sqs.QueueProps;
+    readonly encryptionKey?: kms.Key;
+    readonly encryptionKeyProps?: kms.KeyProps;
+}
+export declare function CheckSqsProps(propsObject: SqsProps | any): void;

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

@@ -0,0 +1,203 @@
+"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.CheckSqsProps = exports.buildDeadLetterQueue = exports.buildQueue = 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 sqs = require("aws-cdk-lib/aws-sqs");
+const defaults = require("./sqs-defaults");
+const utils_1 = require("./utils");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const kms_helper_1 = require("./kms-helper");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildQueue(scope, id, props) {
+    CheckBuidQueueProps(props);
+    let deadLetterQueue;
+    if ((0, utils_1.CheckBooleanWithDefault)(props.deployDeadLetterQueue, true)) {
+        deadLetterQueue = buildDeadLetterQueue(scope, id, {
+            existingQueueObj: props.existingQueueObj,
+            deployDeadLetterQueue: props.deployDeadLetterQueue,
+            deadLetterQueueProps: props.deadLetterQueueProps,
+            constructDeadLetterQueueProps: props.constructDeadLetterQueueProps,
+            maxReceiveCount: props.maxReceiveCount
+        });
+    }
+    // If an existingQueueObj is not specified
+    if (!props.existingQueueObj) {
+        // Setup the queue
+        let queueProps;
+        if (props.queueProps) {
+            // If property overrides have been provided, incorporate them and deploy
+            const checkFifo = props.queueProps.fifo ? true : undefined;
+            queueProps = (0, utils_1.overrideProps)(defaults.DefaultQueueProps(), { ...props.queueProps, fifo: checkFifo });
+        }
+        else {
+            // If no property overrides, deploy using the default configuration
+            queueProps = defaults.DefaultQueueProps();
+        }
+        if (props.constructQueueProps) {
+            queueProps = (0, utils_1.overrideProps)(queueProps, props.constructQueueProps);
+        }
+        // Determine whether a DLQ property should be added
+        if (deadLetterQueue) {
+            queueProps.deadLetterQueue = deadLetterQueue;
+        }
+        // Set encryption properties.
+        // Note that defaults.DefaultQueueProps sets encryption to Server-side KMS encryption with a KMS key managed by SQS.
+        if (props.queueProps?.encryptionMasterKey) {
+            queueProps.encryptionMasterKey = props.queueProps?.encryptionMasterKey;
+        }
+        else if (props.encryptionKey) {
+            queueProps.encryptionMasterKey = props.encryptionKey;
+        }
+        else if (props.encryptionKeyProps || props.enableEncryptionWithCustomerManagedKey === true) {
+            queueProps.encryptionMasterKey = (0, kms_helper_1.buildEncryptionKey)(scope, id, props.encryptionKeyProps);
+        }
+        // NOSONAR (typescript:S6330)
+        // encryption is set to QueueEncryption.KMS_MANAGED by default in DefaultQueueProps, but
+        // Sonarqube can't parse the code well enough to see this. Encryption is confirmed by
+        // the 'Test deployment without imported encryption key' unit test
+        const queue = new sqs.Queue(scope, id, queueProps); // NOSONAR
+        applySecureQueuePolicy(queue);
+        // Return the queue
+        return { queue, key: queue.encryptionMasterKey, dlq: deadLetterQueue };
+    }
+    else {
+        // If an existingQueueObj is specified, return that object as the queue to be used
+        return { queue: props.existingQueueObj };
+    }
+}
+exports.buildQueue = buildQueue;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function CheckBuidQueueProps(props) {
+    if ((props.queueProps?.encryptionMasterKey || props.encryptionKey || props.encryptionKeyProps)
+        && props.enableEncryptionWithCustomerManagedKey !== true) {
+        (0, utils_1.printWarning)(`Ignoring enableEncryptionWithCustomerManagedKey because one of
+     queueProps.encryptionMasterKey, encryptionKey, or encryptionKeyProps was already specified`);
+    }
+    let errorMessages = '';
+    let errorFound = false;
+    if ((props.deployDeadLetterQueue === false) && props.maxReceiveCount) {
+        errorMessages += 'Error - MaxReceiveCount cannot be set if deployDeadLetterQueue is false.\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildDeadLetterQueue(scope, id, props) {
+    if (!props.existingQueueObj && (0, utils_1.CheckBooleanWithDefault)(props.deployDeadLetterQueue, true)) {
+        // Create the Dead Letter Queue
+        const buildQueueResponse = buildQueue(scope, `${id}-dlq`, {
+            queueProps: (0, utils_1.consolidateProps)({}, props.deadLetterQueueProps, props.constructDeadLetterQueueProps),
+            deployDeadLetterQueue: false // don't deploy a DLQ for the DLG!
+        });
+        const mrc = (props.maxReceiveCount) ? props.maxReceiveCount : defaults.defaultMaxReceiveCount;
+        // Setup the Dead Letter Queue interface
+        const deadLetterQueueObject = {
+            maxReceiveCount: mrc,
+            queue: buildQueueResponse.queue
+        };
+        // Return the dead letter queue interface
+        return deadLetterQueueObject;
+    }
+    // ESLint requires this return statement, so disabling SonarQube warning
+    return; // NOSONAR
+}
+exports.buildDeadLetterQueue = buildDeadLetterQueue;
+function applySecureQueuePolicy(queue) {
+    // Apply queue policy to enforce only the queue owner can perform operations on queue
+    queue.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+        sid: 'QueueOwnerOnlyAccess',
+        resources: [
+            `${queue.queueArn}`
+        ],
+        actions: [
+            "sqs:DeleteMessage",
+            "sqs:ReceiveMessage",
+            "sqs:SendMessage",
+            "sqs:GetQueueAttributes",
+            "sqs:RemovePermission",
+            "sqs:AddPermission",
+            "sqs:SetQueueAttributes"
+        ],
+        principals: [new aws_iam_1.AccountPrincipal(aws_cdk_lib_1.Stack.of(queue).account)],
+        effect: aws_iam_1.Effect.ALLOW
+    }));
+    // Apply queue policy to enforce encryption of data in transit
+    queue.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+        sid: 'HttpsOnly',
+        resources: [
+            `${queue.queueArn}`
+        ],
+        actions: [
+            "SQS:*"
+        ],
+        principals: [new aws_iam_1.AnyPrincipal()],
+        effect: aws_iam_1.Effect.DENY,
+        conditions: {
+            Bool: {
+                'aws:SecureTransport': 'false'
+            }
+        }
+    }));
+}
+function CheckSqsProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (propsObject.existingQueueObj && propsObject.queueProps) {
+        errorMessages += 'Error - Either provide queueProps or existingQueueObj, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.queueProps?.encryptionMasterKey && propsObject.encryptionKey) {
+        errorMessages += 'Error - Either provide queueProps.encryptionMasterKey or encryptionKey, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.queueProps?.encryptionMasterKey && propsObject.encryptionKeyProps) {
+        errorMessages += 'Error - Either provide queueProps.encryptionMasterKey or encryptionKeyProps, but not both.\n';
+        errorFound = true;
+    }
+    if (propsObject.encryptionKey && propsObject.encryptionKeyProps) {
+        errorMessages += 'Error - Either provide encryptionKey or encryptionKeyProps, but not both.\n';
+        errorFound = true;
+    }
+    if ((propsObject?.deployDeadLetterQueue === false) && propsObject.deadLetterQueueProps) {
+        errorMessages += 'Error - If deployDeadLetterQueue is false then deadLetterQueueProps cannot be specified.\n';
+        errorFound = true;
+    }
+    const isQueueFifo = propsObject?.queueProps?.fifo;
+    const isDeadLetterQueueFifo = propsObject?.deadLetterQueueProps?.fifo;
+    const deployDeadLetterQueue = (0, utils_1.CheckBooleanWithDefault)(propsObject.deployDeadLetterQueue, true);
+    if (deployDeadLetterQueue && (isQueueFifo !== isDeadLetterQueueFifo)) {
+        errorMessages += 'Error - If you specify a fifo: true in either queueProps or deadLetterQueueProps, you must also set fifo: ' +
+            'true in the other props object. Fifo must match for the Queue and the Dead Letter Queue.\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+exports.CheckSqsProps = CheckSqsProps;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqs-helper.js","sourceRoot":"","sources":["sqs-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 sqs from 'aws-cdk-lib/aws-sqs';\nimport * as defaults from './sqs-defaults';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { CheckBooleanWithDefault, consolidateProps, printWarning,  overrideProps } from './utils';\nimport { AccountPrincipal, Effect, PolicyStatement, AnyPrincipal } from 'aws-cdk-lib/aws-iam';\nimport { Stack } from 'aws-cdk-lib';\nimport {buildEncryptionKey} from \"./kms-helper\";\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\n\nexport interface BuildQueueProps {\n    /**\n     * Existing instance of SQS queue object, providing both this and queueProps will cause an error.\n     *\n     * @default - None.\n     */\n    readonly existingQueueObj?: sqs.Queue;\n    /**\n     * Optional user provided props to override the default props for the primary queue.\n     *\n     * @default - Default props are used.\n     */\n    readonly queueProps?: sqs.QueueProps;\n    /**\n     * Optional props required by the construct that overide both the default and client supplied values\n     *\n     * @default - none\n     */\n    readonly constructQueueProps?: sqs.QueueProps;\n    /**\n     * If no key is provided, this flag determines whether the queue is encrypted with a new CMK or an AWS managed key.\n     * This flag is ignored if any of the following are defined: queueProps.encryptionMasterKey, encryptionKey or encryptionKeyProps.\n     *\n     * @default - False if queueProps.encryptionMasterKey, encryptionKey, and encryptionKeyProps are all undefined.\n     */\n    readonly enableEncryptionWithCustomerManagedKey?: boolean;\n    /**\n     * An optional, imported encryption key to encrypt the SQS Queue with.\n     *\n     * @default - None\n     */\n    readonly encryptionKey?: kms.Key;\n    /**\n     * Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SQS Queue with.\n     *\n     * @default - None\n     */\n     readonly encryptionKeyProps?: kms.KeyProps;\n    /**\n     * Whether to deploy a secondary queue to be used as a dead letter queue.\n     *\n     * @default - true\n     */\n    readonly deployDeadLetterQueue?: boolean,\n    /**\n     * Optional user provided properties for the dead letter queue\n     *\n     * @default - Default props are used\n     */\n    readonly deadLetterQueueProps?: sqs.QueueProps,\n    /**\n     * Optional props required by the construct that overide both the default and client supplied values\n     *\n     * @default - none\n     */\n    readonly constructDeadLetterQueueProps?: sqs.QueueProps,\n    /**\n     * The number of times a message can be unsuccessfully dequeued before being moved to the dead letter queue.\n     *\n     * @default - Default props are used\n     */\n    readonly maxReceiveCount?: number\n}\n\nexport interface BuildQueueResponse {\n  readonly queue: sqs.Queue,\n  readonly key?: kms.IKey,\n  readonly dlq?: sqs.DeadLetterQueue,\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildQueue(scope: Construct, id: string, props: BuildQueueProps): BuildQueueResponse {\n  CheckBuidQueueProps(props);\n  let deadLetterQueue: sqs.DeadLetterQueue | undefined;\n\n  if (CheckBooleanWithDefault( props.deployDeadLetterQueue, true)) {\n    deadLetterQueue = buildDeadLetterQueue(scope, id, {\n      existingQueueObj: props.existingQueueObj,\n      deployDeadLetterQueue: props.deployDeadLetterQueue,\n      deadLetterQueueProps: props.deadLetterQueueProps,\n      constructDeadLetterQueueProps: props.constructDeadLetterQueueProps,\n      maxReceiveCount: props.maxReceiveCount\n    });\n  }\n\n  // If an existingQueueObj is not specified\n  if (!props.existingQueueObj) {\n    // Setup the queue\n    let queueProps;\n    if (props.queueProps) {\n      // If property overrides have been provided, incorporate them and deploy\n      const checkFifo = props.queueProps.fifo ? true : undefined;\n      queueProps = overrideProps(defaults.DefaultQueueProps(), { ...props.queueProps, fifo: checkFifo });\n    } else {\n      // If no property overrides, deploy using the default configuration\n      queueProps = defaults.DefaultQueueProps();\n    }\n    if (props.constructQueueProps) {\n      queueProps = overrideProps(queueProps, props.constructQueueProps);\n    }\n\n    // Determine whether a DLQ property should be added\n    if (deadLetterQueue) {\n      queueProps.deadLetterQueue = deadLetterQueue;\n    }\n\n    // Set encryption properties.\n    // Note that defaults.DefaultQueueProps sets encryption to Server-side KMS encryption with a KMS key managed by SQS.\n    if (props.queueProps?.encryptionMasterKey) {\n      queueProps.encryptionMasterKey = props.queueProps?.encryptionMasterKey;\n    } else if (props.encryptionKey) {\n      queueProps.encryptionMasterKey = props.encryptionKey;\n    } else if (props.encryptionKeyProps || props.enableEncryptionWithCustomerManagedKey === true) {\n      queueProps.encryptionMasterKey = buildEncryptionKey(scope, id, props.encryptionKeyProps);\n    }\n\n    // NOSONAR (typescript:S6330)\n    // encryption is set to QueueEncryption.KMS_MANAGED by default in DefaultQueueProps, but\n    // Sonarqube can't parse the code well enough to see this. Encryption is confirmed by\n    // the 'Test deployment without imported encryption key' unit test\n    const queue = new sqs.Queue(scope, id, queueProps); // NOSONAR\n\n    applySecureQueuePolicy(queue);\n\n    // Return the queue\n    return { queue, key: queue.encryptionMasterKey,  dlq: deadLetterQueue };\n  } else {\n    // If an existingQueueObj is specified, return that object as the queue to be used\n    return { queue: props.existingQueueObj };\n  }\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nfunction CheckBuidQueueProps(props: BuildQueueProps) {\n  if ((props.queueProps?.encryptionMasterKey || props.encryptionKey || props.encryptionKeyProps)\n  && props.enableEncryptionWithCustomerManagedKey !== true) {\n    printWarning(`Ignoring enableEncryptionWithCustomerManagedKey because one of\n     queueProps.encryptionMasterKey, encryptionKey, or encryptionKeyProps was already specified`);\n  }\n\n  let errorMessages = '';\n  let errorFound = false;\n\n  if ((props.deployDeadLetterQueue === false) && props.maxReceiveCount) {\n    errorMessages += 'Error - MaxReceiveCount cannot be set if deployDeadLetterQueue is false.\\n';\n    errorFound = true;\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n\nexport interface BuildDeadLetterQueueProps {\n  /**\n   * Existing instance of SQS queue object, providing both this and queueProps will cause an error.\n   *\n   * @default - None.\n   */\n  readonly existingQueueObj?: sqs.Queue,\n  /**\n   * Whether to deploy a secondary queue to be used as a dead letter queue.\n   *\n   * @default - required field.\n   */\n  readonly deployDeadLetterQueue?: boolean,\n  /**\n   * Optional user provided properties for the dead letter queue\n   *\n   * @default - Default props are used\n   */\n  readonly deadLetterQueueProps?: sqs.QueueProps,\n  /**\n   * Optional Props that override default and client props\n   *\n   * @default - Default props are used\n   */\n  readonly constructDeadLetterQueueProps?: sqs.QueueProps,\n  /**\n   * The number of times a message can be unsuccessfully dequeued before being moved to the dead letter queue.\n   *\n   * @default - Default props are used\n   */\n  readonly maxReceiveCount?: number\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildDeadLetterQueue(scope: Construct, id: string, props: BuildDeadLetterQueueProps): sqs.DeadLetterQueue | undefined {\n  if (!props.existingQueueObj && CheckBooleanWithDefault(props.deployDeadLetterQueue, true)) {\n    // Create the Dead Letter Queue\n    const buildQueueResponse = buildQueue(scope, `${id}-dlq`, {\n      queueProps: consolidateProps({}, props.deadLetterQueueProps, props.constructDeadLetterQueueProps),\n      deployDeadLetterQueue: false  // don't deploy a DLQ for the DLG!\n    });\n\n    const mrc = (props.maxReceiveCount) ? props.maxReceiveCount : defaults.defaultMaxReceiveCount;\n\n    // Setup the Dead Letter Queue interface\n    const deadLetterQueueObject: sqs.DeadLetterQueue = {\n      maxReceiveCount: mrc,\n      queue: buildQueueResponse.queue\n    };\n\n    // Return the dead letter queue interface\n    return deadLetterQueueObject;\n  }\n  // ESLint requires this return statement, so disabling SonarQube warning\n  return; // NOSONAR\n}\n\nfunction applySecureQueuePolicy(queue: sqs.Queue): void {\n\n  // Apply queue policy to enforce only the queue owner can perform operations on queue\n  queue.addToResourcePolicy(\n    new PolicyStatement({\n      sid: 'QueueOwnerOnlyAccess',\n      resources: [\n        `${queue.queueArn}`\n      ],\n      actions: [\n        \"sqs:DeleteMessage\",\n        \"sqs:ReceiveMessage\",\n        \"sqs:SendMessage\",\n        \"sqs:GetQueueAttributes\",\n        \"sqs:RemovePermission\",\n        \"sqs:AddPermission\",\n        \"sqs:SetQueueAttributes\"\n      ],\n      principals: [new AccountPrincipal(Stack.of(queue).account)],\n      effect: Effect.ALLOW\n    })\n  );\n\n  // Apply queue policy to enforce encryption of data in transit\n  queue.addToResourcePolicy(\n    new PolicyStatement({\n      sid: 'HttpsOnly',\n      resources: [\n        `${queue.queueArn}`\n      ],\n      actions: [\n        \"SQS:*\"\n      ],\n      principals: [new AnyPrincipal()],\n      effect: Effect.DENY,\n      conditions:\n          {\n            Bool: {\n              'aws:SecureTransport': 'false'\n            }\n          }\n    })\n  );\n}\n\nexport interface SqsProps {\n  readonly existingQueueObj?: sqs.Queue,\n  readonly queueProps?: sqs.QueueProps,\n  readonly deployDeadLetterQueue?: boolean,\n  readonly deadLetterQueueProps?: sqs.QueueProps,\n  readonly encryptionKey?: kms.Key,\n  readonly encryptionKeyProps?: kms.KeyProps\n}\n\nexport function CheckSqsProps(propsObject: SqsProps | any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (propsObject.existingQueueObj && propsObject.queueProps) {\n    errorMessages += 'Error - Either provide queueProps or existingQueueObj, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.queueProps?.encryptionMasterKey && propsObject.encryptionKey) {\n    errorMessages += 'Error - Either provide queueProps.encryptionMasterKey or encryptionKey, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.queueProps?.encryptionMasterKey && propsObject.encryptionKeyProps) {\n    errorMessages += 'Error - Either provide queueProps.encryptionMasterKey or encryptionKeyProps, but not both.\\n';\n    errorFound = true;\n  }\n\n  if (propsObject.encryptionKey && propsObject.encryptionKeyProps) {\n    errorMessages += 'Error - Either provide encryptionKey or encryptionKeyProps, but not both.\\n';\n    errorFound = true;\n  }\n\n  if ((propsObject?.deployDeadLetterQueue === false) && propsObject.deadLetterQueueProps) {\n    errorMessages += 'Error - If deployDeadLetterQueue is false then deadLetterQueueProps cannot be specified.\\n';\n    errorFound = true;\n  }\n\n  const isQueueFifo: boolean = propsObject?.queueProps?.fifo;\n  const isDeadLetterQueueFifo: boolean = propsObject?.deadLetterQueueProps?.fifo;\n  const deployDeadLetterQueue: boolean = CheckBooleanWithDefault(propsObject.deployDeadLetterQueue, true);\n\n  if (deployDeadLetterQueue && (isQueueFifo !== isDeadLetterQueueFifo)) {\n    errorMessages += 'Error - If you specify a fifo: true in either queueProps or deadLetterQueueProps, you must also set fifo: ' +\n      'true in the other props object. Fifo must match for the Queue and the Dead Letter Queue.\\n';\n    errorFound = true;\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n"]}