@gemeentenijmegen/webapp 0.0.1

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

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

@@ -0,0 +1,17 @@
+/**
+ *  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 mediastore from 'aws-cdk-lib/aws-mediastore';
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function MediaStoreContainerProps(): mediastore.CfnContainerProps;

package/node_modules/@aws-solutions-constructs/core/lib/mediastore-defaults.js

@@ -0,0 +1,72 @@
+"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.MediaStoreContainerProps = void 0;
+/*
+ *  The functions found here in the core library are for internal use and can be changed
+ *  or removed outside of a major release. We recommend against calling them directly from client code.
+ */
+const cdk = require("aws-cdk-lib");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function MediaStoreContainerProps() {
+    return {
+        containerName: cdk.Aws.STACK_NAME,
+        accessLoggingEnabled: true,
+        corsPolicy: [{
+                allowedHeaders: ['*'],
+                allowedMethods: ['GET'],
+                allowedOrigins: ['*'],
+                exposeHeaders: ['*'],
+                maxAgeSeconds: 3000
+            }],
+        policy: JSON.stringify({
+            Version: '2012-10-17',
+            Statement: [{
+                    Sid: 'MediaStoreDefaultPolicy',
+                    Effect: 'Allow',
+                    Principal: '*',
+                    Action: [
+                        'mediastore:GetObject',
+                        'mediastore:DescribeObject'
+                    ],
+                    Resource: `arn:${cdk.Aws.PARTITION}:mediastore:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:container/${cdk.Aws.STACK_NAME}/*`,
+                    Condition: {
+                        Bool: {
+                            'aws:SecureTransport': 'true'
+                        }
+                    }
+                }]
+        }),
+        lifecyclePolicy: JSON.stringify({
+            rules: [{
+                    definition: {
+                        path: [
+                            { wildcard: '*' }
+                        ],
+                        days_since_create: [
+                            { numeric: ['>', 30] }
+                        ]
+                    },
+                    action: 'EXPIRE'
+                }]
+        }),
+        metricPolicy: {
+            containerLevelMetrics: 'ENABLED'
+        }
+    };
+}
+exports.MediaStoreContainerProps = MediaStoreContainerProps;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+/**
+ *  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 mediastore from 'aws-cdk-lib/aws-mediastore';
+import { Construct } from 'constructs';
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function MediaStoreContainer(scope: Construct, mediaStoreContainerProps?: mediastore.CfnContainerProps): mediastore.CfnContainer;
+export interface MediaStoreProps {
+    readonly existingMediaStoreContainerObj?: mediastore.CfnContainer;
+    readonly mediaStoreContainerProps?: mediastore.CfnContainerProps;
+}
+export declare function CheckMediaStoreProps(propsObject: MediaStoreProps | any): void;

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

@@ -0,0 +1,50 @@
+"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.CheckMediaStoreProps = exports.MediaStoreContainer = void 0;
+/*
+ *  The functions found here in the core library are for internal use and can be changed
+ *  or removed outside of a major release. We recommend against calling them directly from client code.
+ */
+const cdk = require("aws-cdk-lib");
+const mediastore = require("aws-cdk-lib/aws-mediastore");
+const mediastore_defaults_1 = require("./mediastore-defaults");
+const utils_1 = require("./utils");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function MediaStoreContainer(scope, mediaStoreContainerProps) {
+    const defaultprops = mediastore_defaults_1.MediaStoreContainerProps();
+    let mediaStoreProps;
+    mediaStoreProps = utils_1.consolidateProps(defaultprops, mediaStoreContainerProps);
+    // Create the MediaStore Container
+    const mediaStoreContainer = new mediastore.CfnContainer(scope, 'MediaStoreContainer', mediaStoreProps);
+    // Add deletion policy to retain because it will fail to delete if the container is not empty.
+    mediaStoreContainer.cfnOptions.deletionPolicy = cdk.CfnDeletionPolicy.RETAIN;
+    return mediaStoreContainer;
+}
+exports.MediaStoreContainer = MediaStoreContainer;
+function CheckMediaStoreProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (propsObject.existingMediaStoreContainerObj && propsObject.mediaStoreContainerProps) {
+        errorMessages += 'Error - Either provide mediaStoreContainerProps or existingMediaStoreContainerObj, but not both.\n';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+exports.CheckMediaStoreProps = CheckMediaStoreProps;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaWFzdG9yZS1oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJtZWRpYXN0b3JlLWhlbHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7Ozs7O0dBV0c7OztBQUVIOzs7R0FHRztBQUVILG1DQUFtQztBQUNuQyx5REFBeUQ7QUFDekQsK0RBQWlFO0FBQ2pFLG1DQUEyQztBQUkzQzs7R0FFRztBQUNILFNBQWdCLG1CQUFtQixDQUFDLEtBQWdCLEVBQUUsd0JBQXVEO0lBQzNHLE1BQU0sWUFBWSxHQUFpQyw4Q0FBd0IsRUFBRSxDQUFDO0lBQzlFLElBQUksZUFBNkMsQ0FBQztJQUVsRCxlQUFlLEdBQUcsd0JBQWdCLENBQUMsWUFBWSxFQUFFLHdCQUF3QixDQUFDLENBQUM7SUFFM0Usa0NBQWtDO0lBQ2xDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxVQUFVLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxlQUFlLENBQUMsQ0FBQztJQUV2Ryw4RkFBOEY7SUFDOUYsbUJBQW1CLENBQUMsVUFBVSxDQUFDLGNBQWMsR0FBRyxHQUFHLENBQUMsaUJBQWlCLENBQUMsTUFBTSxDQUFDO0lBRTdFLE9BQU8sbUJBQW1CLENBQUM7QUFDN0IsQ0FBQztBQWJELGtEQWFDO0FBT0QsU0FBZ0Isb0JBQW9CLENBQUMsV0FBa0M7SUFDckUsSUFBSSxhQUFhLEdBQUcsRUFBRSxDQUFDO0lBQ3ZCLElBQUksVUFBVSxHQUFHLEtBQUssQ0FBQztJQUV2QixJQUFJLFdBQVcsQ0FBQyw4QkFBOEIsSUFBSSxXQUFXLENBQUMsd0JBQXdCLEVBQUU7UUFDdEYsYUFBYSxJQUFJLG9HQUFvRyxDQUFDO1FBQ3RILFVBQVUsR0FBRyxJQUFJLENBQUM7S0FDbkI7SUFFRCxJQUFJLFVBQVUsRUFBRTtRQUNkLE1BQU0sSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUM7S0FDaEM7QUFDSCxDQUFDO0FBWkQsb0RBWUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqICBDb3B5cmlnaHQgQW1hem9uLmNvbSwgSW5jLiBvciBpdHMgYWZmaWxpYXRlcy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiAgTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKS4gWW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZVxuICogIHdpdGggdGhlIExpY2Vuc2UuIEEgY29weSBvZiB0aGUgTGljZW5zZSBpcyBsb2NhdGVkIGF0XG4gKlxuICogICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiAgb3IgaW4gdGhlICdsaWNlbnNlJyBmaWxlIGFjY29tcGFueWluZyB0aGlzIGZpbGUuIFRoaXMgZmlsZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAnQVMgSVMnIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVNcbiAqICBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBleHByZXNzIG9yIGltcGxpZWQuIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9uc1xuICogIGFuZCBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4vKlxuICogIFRoZSBmdW5jdGlvbnMgZm91bmQgaGVyZSBpbiB0aGUgY29yZSBsaWJyYXJ5IGFyZSBmb3IgaW50ZXJuYWwgdXNlIGFuZCBjYW4gYmUgY2hhbmdlZFxuICogIG9yIHJlbW92ZWQgb3V0c2lkZSBvZiBhIG1ham9yIHJlbGVhc2UuIFdlIHJlY29tbWVuZCBhZ2FpbnN0IGNhbGxpbmcgdGhlbSBkaXJlY3RseSBmcm9tIGNsaWVudCBjb2RlLlxuICovXG5cbmltcG9ydCAqIGFzIGNkayBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgKiBhcyBtZWRpYXN0b3JlIGZyb20gJ2F3cy1jZGstbGliL2F3cy1tZWRpYXN0b3JlJztcbmltcG9ydCB7IE1lZGlhU3RvcmVDb250YWluZXJQcm9wcyB9IGZyb20gJy4vbWVkaWFzdG9yZS1kZWZhdWx0cyc7XG5pbXBvcnQgeyBjb25zb2xpZGF0ZVByb3BzIH0gZnJvbSAnLi91dGlscyc7XG4vLyBOb3RlOiBUbyBlbnN1cmUgQ0RLdjIgY29tcGF0aWJpbGl0eSwga2VlcCB0aGUgaW1wb3J0IHN0YXRlbWVudCBmb3IgQ29uc3RydWN0IHNlcGFyYXRlXG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcblxuLyoqXG4gKiBAaW50ZXJuYWwgVGhpcyBpcyBhbiBpbnRlcm5hbCBjb3JlIGZ1bmN0aW9uIGFuZCBzaG91bGQgbm90IGJlIGNhbGxlZCBkaXJlY3RseSBieSBTb2x1dGlvbnMgQ29uc3RydWN0cyBjbGllbnRzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gTWVkaWFTdG9yZUNvbnRhaW5lcihzY29wZTogQ29uc3RydWN0LCBtZWRpYVN0b3JlQ29udGFpbmVyUHJvcHM/OiBtZWRpYXN0b3JlLkNmbkNvbnRhaW5lclByb3BzKTogbWVkaWFzdG9yZS5DZm5Db250YWluZXIge1xuICBjb25zdCBkZWZhdWx0cHJvcHM6IG1lZGlhc3RvcmUuQ2ZuQ29udGFpbmVyUHJvcHMgPSBNZWRpYVN0b3JlQ29udGFpbmVyUHJvcHMoKTtcbiAgbGV0IG1lZGlhU3RvcmVQcm9wczogbWVkaWFzdG9yZS5DZm5Db250YWluZXJQcm9wcztcblxuICBtZWRpYVN0b3JlUHJvcHMgPSBjb25zb2xpZGF0ZVByb3BzKGRlZmF1bHRwcm9wcywgbWVkaWFTdG9yZUNvbnRhaW5lclByb3BzKTtcblxuICAvLyBDcmVhdGUgdGhlIE1lZGlhU3RvcmUgQ29udGFpbmVyXG4gIGNvbnN0IG1lZGlhU3RvcmVDb250YWluZXIgPSBuZXcgbWVkaWFzdG9yZS5DZm5Db250YWluZXIoc2NvcGUsICdNZWRpYVN0b3JlQ29udGFpbmVyJywgbWVkaWFTdG9yZVByb3BzKTtcblxuICAvLyBBZGQgZGVsZXRpb24gcG9saWN5IHRvIHJldGFpbiBiZWNhdXNlIGl0IHdpbGwgZmFpbCB0byBkZWxldGUgaWYgdGhlIGNvbnRhaW5lciBpcyBub3QgZW1wdHkuXG4gIG1lZGlhU3RvcmVDb250YWluZXIuY2ZuT3B0aW9ucy5kZWxldGlvblBvbGljeSA9IGNkay5DZm5EZWxldGlvblBvbGljeS5SRVRBSU47XG5cbiAgcmV0dXJuIG1lZGlhU3RvcmVDb250YWluZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWVkaWFTdG9yZVByb3BzIHtcbiAgcmVhZG9ubHkgZXhpc3RpbmdNZWRpYVN0b3JlQ29udGFpbmVyT2JqPzogbWVkaWFzdG9yZS5DZm5Db250YWluZXI7XG4gIHJlYWRvbmx5IG1lZGlhU3RvcmVDb250YWluZXJQcm9wcz86IG1lZGlhc3RvcmUuQ2ZuQ29udGFpbmVyUHJvcHM7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBDaGVja01lZGlhU3RvcmVQcm9wcyhwcm9wc09iamVjdDogTWVkaWFTdG9yZVByb3BzIHwgYW55KSB7XG4gIGxldCBlcnJvck1lc3NhZ2VzID0gJyc7XG4gIGxldCBlcnJvckZvdW5kID0gZmFsc2U7XG5cbiAgaWYgKHByb3BzT2JqZWN0LmV4aXN0aW5nTWVkaWFTdG9yZUNvbnRhaW5lck9iaiAmJiBwcm9wc09iamVjdC5tZWRpYVN0b3JlQ29udGFpbmVyUHJvcHMpIHtcbiAgICBlcnJvck1lc3NhZ2VzICs9ICdFcnJvciAtIEVpdGhlciBwcm92aWRlIG1lZGlhU3RvcmVDb250YWluZXJQcm9wcyBvciBleGlzdGluZ01lZGlhU3RvcmVDb250YWluZXJPYmosIGJ1dCBub3QgYm90aC5cXG4nO1xuICAgIGVycm9yRm91bmQgPSB0cnVlO1xuICB9XG5cbiAgaWYgKGVycm9yRm91bmQpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoZXJyb3JNZXNzYWdlcyk7XG4gIH1cbn1cbiJdfQ==

package/node_modules/@aws-solutions-constructs/core/lib/opensearch-defaults.d.ts

@@ -0,0 +1,19 @@
+/**
+ *  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 opensearch from 'aws-cdk-lib/aws-opensearchservice';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { BuildOpenSearchProps } from './opensearch-helper';
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function DefaultOpenSearchCfnDomainProps(domainName: string, cognitoConfigureRole: iam.Role, props: BuildOpenSearchProps): opensearch.CfnDomainProps;

package/node_modules/@aws-solutions-constructs/core/lib/opensearch-defaults.js

@@ -0,0 +1,72 @@
+"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.DefaultOpenSearchCfnDomainProps = void 0;
+const iam = require("aws-cdk-lib/aws-iam");
+const cdk = require("aws-cdk-lib");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function DefaultOpenSearchCfnDomainProps(domainName, cognitoConfigureRole, props) {
+    const roleARNs = [];
+    roleARNs.push(new iam.ArnPrincipal(props.cognitoAuthorizedRoleARN));
+    if (props.serviceRoleARN) {
+        roleARNs.push(new iam.ArnPrincipal(props.serviceRoleARN));
+    }
+    // Features supported by engine version:
+    // https://docs.aws.amazon.com/opensearch-service/latest/developerguide/features-by-version.html
+    // https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_opensearchservice.CfnDomainProps.html
+    return {
+        domainName,
+        engineVersion: 'OpenSearch_1.3',
+        encryptionAtRestOptions: {
+            enabled: true
+        },
+        nodeToNodeEncryptionOptions: {
+            enabled: true
+        },
+        snapshotOptions: {
+            automatedSnapshotStartHour: 1
+        },
+        ebsOptions: {
+            ebsEnabled: true,
+            volumeSize: 10
+        },
+        cognitoOptions: {
+            enabled: true,
+            identityPoolId: props.identitypool.ref,
+            userPoolId: props.userpool.userPoolId,
+            roleArn: cognitoConfigureRole.roleArn
+        },
+        domainEndpointOptions: {
+            enforceHttps: true,
+            tlsSecurityPolicy: 'Policy-Min-TLS-1-2-2019-07',
+        },
+        accessPolicies: new iam.PolicyDocument({
+            statements: [
+                new iam.PolicyStatement({
+                    principals: roleARNs,
+                    actions: [
+                        'es:ESHttp*'
+                    ],
+                    resources: [
+                        `arn:${cdk.Aws.PARTITION}:es:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:domain/${domainName}/*`
+                    ]
+                })
+            ]
+        })
+    };
+}
+exports.DefaultOpenSearchCfnDomainProps = DefaultOpenSearchCfnDomainProps;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,44 @@
+/**
+ *  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 opensearch from 'aws-cdk-lib/aws-opensearchservice';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+import * as cognito from 'aws-cdk-lib/aws-cognito';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+export interface BuildOpenSearchProps {
+    readonly identitypool: cognito.CfnIdentityPool;
+    readonly userpool: cognito.UserPool;
+    readonly cognitoAuthorizedRoleARN: string;
+    readonly serviceRoleARN?: string;
+    readonly vpc?: ec2.IVpc;
+    readonly openSearchDomainName: string;
+    readonly clientDomainProps?: opensearch.CfnDomainProps;
+    readonly securityGroupIds?: string[];
+}
+export interface BuildOpenSearchResponse {
+    readonly domain: opensearch.CfnDomain;
+    readonly role: iam.Role;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildOpenSearch(scope: Construct, props: BuildOpenSearchProps): BuildOpenSearchResponse;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildOpenSearchCWAlarms(scope: Construct): cloudwatch.Alarm[];
+export interface OpenSearchProps {
+    readonly openSearchDomainProps?: opensearch.CfnDomainProps;
+}
+export declare function CheckOpenSearchProps(propsObject: OpenSearchProps | any): void;