@gemeentenijmegen/webapp 1.0.0 → 1.1.0

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-solutions-constructs/core/lib/cloudfront-distribution-defaults.js

@@ -0,0 +1,100 @@
+"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.DefaultCloudFrontDistributionForMediaStoreProps = exports.DefaultCloudFrontWebDistributionForS3Props = exports.DefaultCloudFrontWebDistributionForApiGatewayProps = void 0;
+const cloudfront = require("aws-cdk-lib/aws-cloudfront");
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const origins = require("aws-cdk-lib/aws-cloudfront-origins");
+const cdk = require("aws-cdk-lib");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint, loggingBucket, setHttpSecurityHeaders, cfFunction, responseHeadersPolicy) {
+    const apiEndPointUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split("://", apiEndPoint.url));
+    const apiEndPointDomainName = cdk.Fn.select(0, cdk.Fn.split("/", apiEndPointUrlWithoutProtocol));
+    let defaultBehavior = {
+        origin: new origins.HttpOrigin(apiEndPointDomainName, {
+            originPath: `/${apiEndPoint.deploymentStage.stageName}`
+        }),
+        ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction),
+        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+    };
+    if (responseHeadersPolicy) {
+        defaultBehavior = { ...defaultBehavior, responseHeadersPolicy };
+    }
+    return {
+        defaultBehavior,
+        enableLogging: true,
+        logBucket: loggingBucket,
+    };
+}
+exports.DefaultCloudFrontWebDistributionForApiGatewayProps = DefaultCloudFrontWebDistributionForApiGatewayProps;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function DefaultCloudFrontWebDistributionForS3Props(origin, loggingBucket, setHttpSecurityHeaders, cfFunction, responseHeadersPolicy) {
+    let defaultBehavior = {
+        origin,
+        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)
+    };
+    if (responseHeadersPolicy) {
+        defaultBehavior = { ...defaultBehavior, responseHeadersPolicy };
+    }
+    return {
+        defaultBehavior,
+        enableLogging: true,
+        logBucket: loggingBucket,
+        defaultRootObject: 'index.html'
+    };
+}
+exports.DefaultCloudFrontWebDistributionForS3Props = DefaultCloudFrontWebDistributionForS3Props;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function DefaultCloudFrontDistributionForMediaStoreProps(mediastoreContainer, loggingBucket, originRequestPolicy, setHttpSecurityHeaders, customHeaders, cfFunction, responseHeadersPolicy) {
+    const mediaStoreContainerUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split('://', mediastoreContainer.attrEndpoint));
+    const mediaStoreContainerDomainName = cdk.Fn.select(0, cdk.Fn.split('/', mediaStoreContainerUrlWithoutProtocol));
+    const httpOrigin = customHeaders ?
+        new origins.HttpOrigin(mediaStoreContainerDomainName, { customHeaders }) :
+        new origins.HttpOrigin(mediaStoreContainerDomainName);
+    let defaultBehavior = {
+        origin: httpOrigin,
+        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+        cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+        originRequestPolicy,
+        ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction),
+    };
+    if (responseHeadersPolicy) {
+        defaultBehavior = { ...defaultBehavior, responseHeadersPolicy };
+    }
+    return {
+        defaultBehavior,
+        enableLogging: true,
+        logBucket: loggingBucket
+    };
+}
+exports.DefaultCloudFrontDistributionForMediaStoreProps = DefaultCloudFrontDistributionForMediaStoreProps;
+function getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction) {
+    return (setHttpSecurityHeaders && cfFunction) ? {
+        functionAssociations: [
+            {
+                eventType: aws_cloudfront_1.FunctionEventType.VIEWER_RESPONSE,
+                function: cfFunction
+            }
+        ]
+    } : {};
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-distribution-defaults.js","sourceRoot":"","sources":["cloudfront-distribution-defaults.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 api from 'aws-cdk-lib/aws-apigateway';\nimport * as cloudfront from 'aws-cdk-lib/aws-cloudfront';\nimport { FunctionEventType, IOrigin } from 'aws-cdk-lib/aws-cloudfront';\nimport * as origins from 'aws-cdk-lib/aws-cloudfront-origins';\nimport * as mediastore from 'aws-cdk-lib/aws-mediastore';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as cdk from 'aws-cdk-lib';\nimport {BehaviorOptions} from \"aws-cdk-lib/aws-cloudfront/lib/distribution\";\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint: api.RestApi,\n  loggingBucket: s3.Bucket | undefined,\n  setHttpSecurityHeaders: boolean,\n  cfFunction?: cloudfront.IFunction,\n  responseHeadersPolicy?: cloudfront.ResponseHeadersPolicy,\n): cloudfront.DistributionProps {\n\n  const apiEndPointUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split(\"://\", apiEndPoint.url));\n  const apiEndPointDomainName = cdk.Fn.select(0, cdk.Fn.split(\"/\", apiEndPointUrlWithoutProtocol));\n\n  let defaultBehavior: BehaviorOptions = {\n    origin: new origins.HttpOrigin(apiEndPointDomainName, {\n      originPath: `/${apiEndPoint.deploymentStage.stageName}`\n    }),\n    ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction),\n    viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n  };\n  if (responseHeadersPolicy) {\n    defaultBehavior = {...defaultBehavior, responseHeadersPolicy };\n  }\n  return {\n    defaultBehavior,\n    enableLogging: true,\n    logBucket: loggingBucket,\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 DefaultCloudFrontWebDistributionForS3Props(\n  origin: IOrigin,\n  loggingBucket: s3.Bucket | undefined,\n  setHttpSecurityHeaders: boolean,\n  cfFunction?: cloudfront.IFunction,\n  responseHeadersPolicy?: cloudfront.ResponseHeadersPolicy,\n): cloudfront.DistributionProps {\n\n  let defaultBehavior: BehaviorOptions = {\n    origin,\n    viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n    ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction)\n  };\n\n  if (responseHeadersPolicy) {\n    defaultBehavior = {...defaultBehavior, responseHeadersPolicy };\n  }\n  return {\n    defaultBehavior,\n    enableLogging: true,\n    logBucket: loggingBucket,\n    defaultRootObject: 'index.html'\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 DefaultCloudFrontDistributionForMediaStoreProps(mediastoreContainer: mediastore.CfnContainer,\n  loggingBucket: s3.Bucket | undefined,\n  originRequestPolicy: cloudfront.OriginRequestPolicy,\n  setHttpSecurityHeaders: boolean,\n  customHeaders?: Record<string, string>,\n  cfFunction?: cloudfront.IFunction,\n  responseHeadersPolicy?: cloudfront.ResponseHeadersPolicy\n): cloudfront.DistributionProps {\n\n  const mediaStoreContainerUrlWithoutProtocol = cdk.Fn.select(1, cdk.Fn.split('://', mediastoreContainer.attrEndpoint));\n  const mediaStoreContainerDomainName = cdk.Fn.select(0, cdk.Fn.split('/', mediaStoreContainerUrlWithoutProtocol));\n\n  const httpOrigin: origins.HttpOrigin = customHeaders ?\n    new origins.HttpOrigin(mediaStoreContainerDomainName, { customHeaders }) :\n    new origins.HttpOrigin(mediaStoreContainerDomainName);\n\n  let defaultBehavior: BehaviorOptions = {\n    origin: httpOrigin,\n    viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n    allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n    cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,\n    originRequestPolicy,\n    ...getFunctionAssociationsProp(setHttpSecurityHeaders, cfFunction),\n  };\n  if (responseHeadersPolicy) {\n    defaultBehavior = {...defaultBehavior, responseHeadersPolicy };\n  }\n  return {\n    defaultBehavior,\n    enableLogging: true,\n    logBucket: loggingBucket\n  };\n}\n\nfunction getFunctionAssociationsProp(setHttpSecurityHeaders: boolean, cfFunction: cloudfront.IFunction | undefined) {\n  return (setHttpSecurityHeaders && cfFunction) ? {\n    functionAssociations: [\n      {\n        eventType: FunctionEventType.VIEWER_RESPONSE,\n        function: cfFunction\n      }\n    ]\n  } : {};\n}\n"]}

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

@@ -0,0 +1,65 @@
+/**
+ *  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 cloudfront from 'aws-cdk-lib/aws-cloudfront';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as api from 'aws-cdk-lib/aws-apigateway';
+import * as mediastore from 'aws-cdk-lib/aws-mediastore';
+import { Construct } from 'constructs';
+export interface CloudFrontDistributionForApiGatewayResponse {
+    readonly distribution: cloudfront.Distribution;
+    readonly cloudfrontFunction?: cloudfront.Function;
+    readonly loggingBucket?: s3.Bucket;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function CloudFrontDistributionForApiGateway(scope: Construct, apiEndPoint: api.RestApi, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean, cloudFrontLoggingBucketProps?: s3.BucketProps, responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps): CloudFrontDistributionForApiGatewayResponse;
+export interface CreateCloudFrontDistributionForS3Props {
+    readonly sourceBucket: s3.IBucket;
+    readonly cloudFrontDistributionProps?: cloudfront.DistributionProps | any;
+    readonly httpSecurityHeaders?: boolean;
+    readonly cloudFrontLoggingBucketProps?: s3.BucketProps;
+    readonly cloudFrontLoggingBucketS3AccessLogBucketProps?: s3.BucketProps;
+    readonly responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps;
+    readonly logCloudFrontAccessLog?: boolean;
+}
+export interface CreateCloudFrontDistributionForS3Response {
+    readonly distribution: cloudfront.Distribution;
+    readonly loggingBucket?: s3.Bucket;
+    readonly loggingBucketS3AccesssLogBucket?: s3.Bucket;
+    readonly cloudfrontFunction?: cloudfront.Function;
+    readonly originAccessControl?: cloudfront.CfnOriginAccessControl;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function createCloudFrontDistributionForS3(scope: Construct, id: string, props: CreateCloudFrontDistributionForS3Props): CreateCloudFrontDistributionForS3Response;
+export interface CloudFrontDistributionForMediaStoreResponse {
+    readonly distribution: cloudfront.Distribution;
+    readonly loggingBucket?: s3.Bucket;
+    readonly requestPolicy: cloudfront.OriginRequestPolicy;
+    readonly cloudfrontFunction?: cloudfront.Function;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function CloudFrontDistributionForMediaStore(scope: Construct, mediaStoreContainer: mediastore.CfnContainer, cloudFrontDistributionProps?: cloudfront.DistributionProps | any, httpSecurityHeaders?: boolean, cloudFrontLoggingBucketProps?: s3.BucketProps, responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps): CloudFrontDistributionForMediaStoreResponse;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function CloudFrontOriginAccessIdentity(scope: Construct, comment?: string): cloudfront.OriginAccessIdentity;
+export interface CloudFrontProps {
+    readonly insertHttpSecurityHeaders?: boolean;
+    readonly responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps;
+}
+export declare function CheckCloudFrontProps(propsObject: CloudFrontProps | any): void;

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

@@ -0,0 +1,226 @@
+"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.CheckCloudFrontProps = exports.CloudFrontOriginAccessIdentity = exports.CloudFrontDistributionForMediaStore = exports.createCloudFrontDistributionForS3 = exports.CloudFrontDistributionForApiGateway = 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 cloudfront = require("aws-cdk-lib/aws-cloudfront");
+const s3 = require("aws-cdk-lib/aws-s3");
+const cdk = require("aws-cdk-lib");
+const cloudfront_distribution_defaults_1 = require("./cloudfront-distribution-defaults");
+const utils_1 = require("./utils");
+const s3_bucket_helper_1 = require("./s3-bucket-helper");
+const s3_bucket_defaults_1 = require("./s3-bucket-defaults");
+const s3_oac_origin_1 = require("./s3-oac-origin");
+// Override Cfn_Nag rule: Cloudfront TLS-1.2 rule (https://github.com/stelligent/cfn_nag/issues/384)
+function updateSecurityPolicy(cfDistribution) {
+    (0, utils_1.addCfnSuppressRules)(cfDistribution, [
+        {
+            id: 'W70',
+            reason: `Since the distribution uses the CloudFront domain name, CloudFront automatically sets the security policy to TLSv1 regardless of the value of MinimumProtocolVersion`
+        }
+    ]);
+    return cfDistribution;
+}
+// Cloudfront function to insert the HTTP Security Headers into the response coming from the origin servers
+// and before it is sent to the client
+function defaultCloudfrontFunction(scope) {
+    // generate a stable unique id for the cloudfront function and use it
+    // both for the function name and the logical id of the function so if
+    // it is changed the function will be recreated.
+    // see https://github.com/aws/aws-cdk/issues/15523
+    const functionId = `SetHttpSecurityHeaders${scope.node.addr}`;
+    return new cloudfront.Function(scope, "SetHttpSecurityHeaders", {
+        functionName: functionId,
+        code: cloudfront.FunctionCode.fromInline("function handler(event) { " +
+            "var response = event.response; " +
+            "var headers = response.headers; " +
+            "headers['strict-transport-security'] = { value: 'max-age=63072000; includeSubdomains; preload'}; " +
+            "headers['content-security-policy'] = { value: \"default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'\"}; " +
+            "headers['x-content-type-options'] = { value: 'nosniff'}; headers['x-frame-options'] = {value: 'DENY'}; " +
+            "headers['x-xss-protection'] = {value: '1; mode=block'}; " +
+            "return response; }")
+    });
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function CloudFrontDistributionForApiGateway(scope, apiEndPoint, cloudFrontDistributionProps, httpSecurityHeaders = true, cloudFrontLoggingBucketProps, responseHeadersPolicyProps) {
+    const cloudfrontFunction = getCloudfrontFunction(httpSecurityHeaders, scope);
+    const getLoggingBucketResponse = getLoggingBucket(scope, { cloudFrontLoggingBucketProps, cloudFrontDistributionProps });
+    const defaultprops = (0, cloudfront_distribution_defaults_1.DefaultCloudFrontWebDistributionForApiGatewayProps)(apiEndPoint, getLoggingBucketResponse.logBucket, httpSecurityHeaders, cloudfrontFunction, responseHeadersPolicyProps ? new cloudfront.ResponseHeadersPolicy(scope, 'ResponseHeadersPolicy', responseHeadersPolicyProps) : undefined);
+    const cfprops = (0, utils_1.consolidateProps)(defaultprops, cloudFrontDistributionProps);
+    // Create the Cloudfront Distribution
+    const cfDistribution = new cloudfront.Distribution(scope, 'CloudFrontDistribution', cfprops);
+    updateSecurityPolicy(cfDistribution);
+    return { distribution: cfDistribution, cloudfrontFunction, loggingBucket: getLoggingBucketResponse.logBucket };
+}
+exports.CloudFrontDistributionForApiGateway = CloudFrontDistributionForApiGateway;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function createCloudFrontDistributionForS3(scope, id, props) {
+    const httpSecurityHeaders = props.httpSecurityHeaders ?? true;
+    const cloudfrontFunction = getCloudfrontFunction(httpSecurityHeaders, scope);
+    const getLoggingBucketResponse = getLoggingBucket(scope, {
+        cloudFrontDistributionProps: props.cloudFrontDistributionProps,
+        cloudFrontLoggingBucketProps: props.cloudFrontLoggingBucketProps,
+        cloudFrontLoggingBucketS3AccessLogBucketProps: props.cloudFrontLoggingBucketS3AccessLogBucketProps,
+        enableS3AccessLogs: props.logCloudFrontAccessLog
+    });
+    let originAccessControl;
+    let originProps = {};
+    if (!props.sourceBucket.isWebsite) {
+        originAccessControl = new cloudfront.CfnOriginAccessControl(scope, 'CloudFrontOac', {
+            originAccessControlConfig: {
+                name: (0, utils_1.generatePhysicalName)('aws-cloudfront-s3-', [id], 64),
+                originAccessControlOriginType: 's3',
+                signingBehavior: 'always',
+                signingProtocol: 'sigv4',
+                description: 'Origin access control provisioned by aws-cloudfront-s3'
+            }
+        });
+        originProps = { originAccessControl };
+    }
+    const origin = new s3_oac_origin_1.S3OacOrigin(props.sourceBucket, originProps);
+    const defaultprops = (0, cloudfront_distribution_defaults_1.DefaultCloudFrontWebDistributionForS3Props)(origin, getLoggingBucketResponse.logBucket, httpSecurityHeaders, cloudfrontFunction, props.responseHeadersPolicyProps ?
+        new cloudfront.ResponseHeadersPolicy(scope, 'ResponseHeadersPolicy', props.responseHeadersPolicyProps) :
+        undefined);
+    const cfprops = (0, utils_1.consolidateProps)(defaultprops, props.cloudFrontDistributionProps);
+    // Create the Cloudfront Distribution
+    const cfDistribution = new cloudfront.Distribution(scope, 'CloudFrontDistribution', cfprops);
+    updateSecurityPolicy(cfDistribution);
+    // Extract the CfnBucketPolicy from the sourceBucket
+    const bucketPolicy = props.sourceBucket.policy;
+    // the lack of a bucketPolicy means the bucket was imported from outside the stack so the lack of cfn_nag suppression is not an issue
+    if (bucketPolicy) {
+        (0, utils_1.addCfnSuppressRules)(bucketPolicy, [
+            {
+                id: 'F16',
+                reason: `Public website bucket policy requires a wildcard principal`
+            }
+        ]);
+    }
+    return {
+        distribution: cfDistribution,
+        cloudfrontFunction,
+        loggingBucket: getLoggingBucketResponse.logBucket,
+        loggingBucketS3AccesssLogBucket: getLoggingBucketResponse.logBucketAccessLogBucket,
+        originAccessControl
+    };
+}
+exports.createCloudFrontDistributionForS3 = createCloudFrontDistributionForS3;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function CloudFrontDistributionForMediaStore(scope, mediaStoreContainer, cloudFrontDistributionProps, httpSecurityHeaders = true, cloudFrontLoggingBucketProps, responseHeadersPolicyProps) {
+    let originRequestPolicy;
+    const getLoggingBucketResponse = getLoggingBucket(scope, { cloudFrontDistributionProps, cloudFrontLoggingBucketProps });
+    if (cloudFrontDistributionProps
+        && cloudFrontDistributionProps.defaultBehavior
+        && cloudFrontDistributionProps.defaultBehavior.originRequestPolicy) {
+        originRequestPolicy = cloudFrontDistributionProps.defaultBehavior.originRequestPolicy;
+    }
+    else {
+        const originRequestPolicyProps = {
+            headerBehavior: {
+                behavior: 'whitelist',
+                headers: [
+                    'Access-Control-Allow-Origin',
+                    'Access-Control-Request-Method',
+                    'Access-Control-Request-Header',
+                    'Origin'
+                ]
+            },
+            queryStringBehavior: {
+                behavior: 'all'
+            },
+            cookieBehavior: {
+                behavior: 'none'
+            },
+            comment: 'Policy for Constructs CloudFrontDistributionForMediaStore',
+            originRequestPolicyName: `${cdk.Aws.STACK_NAME}-${cdk.Aws.REGION}-CloudFrontDistributionForMediaStore`
+        };
+        originRequestPolicy = new cloudfront.OriginRequestPolicy(scope, 'CloudfrontOriginRequestPolicy', originRequestPolicyProps);
+    }
+    const cloudfrontFunction = getCloudfrontFunction(httpSecurityHeaders, scope);
+    const defaultprops = (0, cloudfront_distribution_defaults_1.DefaultCloudFrontDistributionForMediaStoreProps)(mediaStoreContainer, getLoggingBucketResponse.logBucket, originRequestPolicy, httpSecurityHeaders, cloudFrontDistributionProps?.customHeaders, cloudfrontFunction, responseHeadersPolicyProps ? new cloudfront.ResponseHeadersPolicy(scope, 'ResponseHeadersPolicy', responseHeadersPolicyProps) : undefined);
+    let cfprops;
+    cfprops = (0, utils_1.consolidateProps)(defaultprops, cloudFrontDistributionProps);
+    // Create the CloudFront Distribution
+    const cfDistribution = new cloudfront.Distribution(scope, 'CloudFrontDistribution', cfprops);
+    updateSecurityPolicy(cfDistribution);
+    return { distribution: cfDistribution, loggingBucket: getLoggingBucketResponse.logBucket, requestPolicy: originRequestPolicy, cloudfrontFunction };
+}
+exports.CloudFrontDistributionForMediaStore = CloudFrontDistributionForMediaStore;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function CloudFrontOriginAccessIdentity(scope, comment) {
+    return new cloudfront.OriginAccessIdentity(scope, 'CloudFrontOriginAccessIdentity', {
+        comment: comment ? comment : `access-identity-${cdk.Aws.REGION}-${cdk.Aws.STACK_NAME}`
+    });
+}
+exports.CloudFrontOriginAccessIdentity = CloudFrontOriginAccessIdentity;
+function getLoggingBucket(scope, props) {
+    const isLoggingDisabled = props.cloudFrontDistributionProps?.enableLogging === false;
+    const userSuppliedLogBucket = props.cloudFrontDistributionProps?.logBucket;
+    if (userSuppliedLogBucket && props.cloudFrontLoggingBucketProps) {
+        throw Error('Either cloudFrontDistributionProps.logBucket or cloudFrontLoggingBucketProps can be set.');
+    }
+    let logBucket;
+    let logBuckeS3AccessLogBuckett;
+    if (isLoggingDisabled) {
+        logBucket = undefined;
+    }
+    else if (userSuppliedLogBucket) {
+        logBucket = userSuppliedLogBucket;
+    }
+    else {
+        const createBucketResponse = (0, s3_bucket_helper_1.createCloudFrontLoggingBucket)(scope, 'CloudfrontLoggingBucket', {
+            // Buckets used for CloudFront distribution logging require ACLs to be explicitly enabled, so we apply this objectOwnership
+            loggingBucketProps: (0, utils_1.consolidateProps)((0, s3_bucket_defaults_1.DefaultS3Props)(), props.cloudFrontLoggingBucketProps, {
+                objectOwnership: s3.ObjectOwnership.OBJECT_WRITER
+            }),
+            s3AccessLogBucketProps: props.cloudFrontLoggingBucketS3AccessLogBucketProps,
+            enableS3AccessLogs: props.enableS3AccessLogs
+        });
+        logBucket = createBucketResponse.logBucket;
+        logBuckeS3AccessLogBuckett = createBucketResponse.s3AccessLogBucket;
+        const loggingBucketResource = logBucket.node.findChild('Resource');
+        loggingBucketResource.addPropertyOverride('AccessControl', 'LogDeliveryWrite');
+    }
+    return {
+        logBucket,
+        logBucketAccessLogBucket: logBuckeS3AccessLogBuckett
+    };
+}
+function getCloudfrontFunction(httpSecurityHeaders, scope) {
+    return httpSecurityHeaders ? defaultCloudfrontFunction(scope) : undefined;
+}
+function CheckCloudFrontProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (propsObject.insertHttpSecurityHeaders !== false && propsObject.responseHeadersPolicyProps?.securityHeadersBehavior) {
+        errorMessages += 'responseHeadersPolicyProps.securityHeadersBehavior can only be passed if httpSecurityHeaders is set to `false`.';
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+exports.CheckCloudFrontProps = CheckCloudFrontProps;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-distribution-helper.js","sourceRoot":"","sources":["cloudfront-distribution-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 cloudfront from 'aws-cdk-lib/aws-cloudfront';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as cdk from 'aws-cdk-lib';\nimport * as api from 'aws-cdk-lib/aws-apigateway';\nimport * as mediastore from 'aws-cdk-lib/aws-mediastore';\nimport {\n  DefaultCloudFrontWebDistributionForS3Props,\n  DefaultCloudFrontWebDistributionForApiGatewayProps,\n  DefaultCloudFrontDistributionForMediaStoreProps\n} from './cloudfront-distribution-defaults';\nimport { addCfnSuppressRules, consolidateProps, generatePhysicalName } from './utils';\nimport { createCloudFrontLoggingBucket } from './s3-bucket-helper';\nimport { DefaultS3Props } from './s3-bucket-defaults';\nimport { S3OacOrigin } from './s3-oac-origin';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\n\n// Override Cfn_Nag rule: Cloudfront TLS-1.2 rule (https://github.com/stelligent/cfn_nag/issues/384)\nfunction updateSecurityPolicy(cfDistribution: cloudfront.Distribution) {\n  addCfnSuppressRules(cfDistribution, [\n    {\n      id: 'W70',\n      reason: `Since the distribution uses the CloudFront domain name, CloudFront automatically sets the security policy to TLSv1 regardless of the value of MinimumProtocolVersion`\n    }\n  ]);\n\n  return cfDistribution;\n}\n\n// Cloudfront function to insert the HTTP Security Headers into the response coming from the origin servers\n// and before it is sent to the client\nfunction defaultCloudfrontFunction(scope: Construct): cloudfront.Function {\n  // generate a stable unique id for the cloudfront function and use it\n  // both for the function name and the logical id of the function so if\n  // it is changed the function will be recreated.\n  // see https://github.com/aws/aws-cdk/issues/15523\n  const functionId = `SetHttpSecurityHeaders${scope.node.addr}`;\n\n  return new cloudfront.Function(scope, \"SetHttpSecurityHeaders\", {\n    functionName: functionId,\n    code: cloudfront.FunctionCode.fromInline(\"function handler(event) { \" +\n      \"var response = event.response; \" +\n      \"var headers = response.headers; \" +\n      \"headers['strict-transport-security'] = { value: 'max-age=63072000; includeSubdomains; preload'}; \" +\n      \"headers['content-security-policy'] = { value: \\\"default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'\\\"}; \" +\n      \"headers['x-content-type-options'] = { value: 'nosniff'}; headers['x-frame-options'] = {value: 'DENY'}; \" +\n      \"headers['x-xss-protection'] = {value: '1; mode=block'}; \" +\n      \"return response; }\")\n  });\n}\n\nexport interface CloudFrontDistributionForApiGatewayResponse {\n  readonly distribution: cloudfront.Distribution,\n  readonly cloudfrontFunction?: cloudfront.Function,\n  readonly loggingBucket?: s3.Bucket\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function CloudFrontDistributionForApiGateway(scope: Construct,\n  apiEndPoint: api.RestApi,\n  cloudFrontDistributionProps?: cloudfront.DistributionProps | any,\n  httpSecurityHeaders: boolean = true,\n  cloudFrontLoggingBucketProps?: s3.BucketProps,\n  responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps\n): CloudFrontDistributionForApiGatewayResponse {\n\n  const cloudfrontFunction = getCloudfrontFunction(httpSecurityHeaders, scope);\n\n  const getLoggingBucketResponse = getLoggingBucket(scope,  { cloudFrontLoggingBucketProps, cloudFrontDistributionProps });\n\n  const defaultprops = DefaultCloudFrontWebDistributionForApiGatewayProps(apiEndPoint,\n    getLoggingBucketResponse.logBucket,\n    httpSecurityHeaders,\n    cloudfrontFunction,\n    responseHeadersPolicyProps ? new cloudfront.ResponseHeadersPolicy(scope, 'ResponseHeadersPolicy', responseHeadersPolicyProps) : undefined\n  );\n\n  const cfprops = consolidateProps(defaultprops, cloudFrontDistributionProps);\n  // Create the Cloudfront Distribution\n  const cfDistribution = new cloudfront.Distribution(scope, 'CloudFrontDistribution', cfprops);\n  updateSecurityPolicy(cfDistribution);\n\n  return { distribution: cfDistribution, cloudfrontFunction, loggingBucket: getLoggingBucketResponse.logBucket};\n}\n\nexport interface CreateCloudFrontDistributionForS3Props {\n  readonly sourceBucket: s3.IBucket,\n  readonly cloudFrontDistributionProps?: cloudfront.DistributionProps | any,\n  readonly httpSecurityHeaders?: boolean,\n  readonly cloudFrontLoggingBucketProps?: s3.BucketProps,\n  readonly  cloudFrontLoggingBucketS3AccessLogBucketProps?: s3.BucketProps,\n  readonly responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps\n  readonly logCloudFrontAccessLog?: boolean\n}\n\nexport interface CreateCloudFrontDistributionForS3Response {\n  readonly distribution: cloudfront.Distribution,\n  readonly loggingBucket?: s3.Bucket,\n  readonly loggingBucketS3AccesssLogBucket?: s3.Bucket,\n  readonly cloudfrontFunction?: cloudfront.Function,\n  readonly originAccessControl?: cloudfront.CfnOriginAccessControl,\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function createCloudFrontDistributionForS3(\n  scope: Construct,\n  id: string,\n  props: CreateCloudFrontDistributionForS3Props\n): CreateCloudFrontDistributionForS3Response {\n  const httpSecurityHeaders = props.httpSecurityHeaders ?? true;\n  const cloudfrontFunction = getCloudfrontFunction(httpSecurityHeaders, scope);\n\n  const getLoggingBucketResponse = getLoggingBucket(scope, {\n    cloudFrontDistributionProps: props.cloudFrontDistributionProps,\n    cloudFrontLoggingBucketProps: props.cloudFrontLoggingBucketProps,\n    cloudFrontLoggingBucketS3AccessLogBucketProps: props.cloudFrontLoggingBucketS3AccessLogBucketProps,\n    enableS3AccessLogs: props.logCloudFrontAccessLog\n  });\n\n  let originAccessControl;\n  let originProps = {};\n\n  if (!props.sourceBucket.isWebsite) {\n    originAccessControl = new cloudfront.CfnOriginAccessControl(scope, 'CloudFrontOac', {\n      originAccessControlConfig: {\n        name: generatePhysicalName('aws-cloudfront-s3-', [id], 64),\n        originAccessControlOriginType: 's3',\n        signingBehavior: 'always',\n        signingProtocol: 'sigv4',\n        description: 'Origin access control provisioned by aws-cloudfront-s3'\n      }\n    });\n    originProps = { originAccessControl };\n  }\n\n  const origin = new S3OacOrigin(props.sourceBucket, originProps);\n\n  const defaultprops = DefaultCloudFrontWebDistributionForS3Props(origin,\n    getLoggingBucketResponse.logBucket,\n    httpSecurityHeaders,\n    cloudfrontFunction,\n    props.responseHeadersPolicyProps ?\n      new cloudfront.ResponseHeadersPolicy(scope, 'ResponseHeadersPolicy', props.responseHeadersPolicyProps) :\n      undefined\n  );\n\n  const cfprops = consolidateProps(defaultprops, props.cloudFrontDistributionProps);\n  // Create the Cloudfront Distribution\n  const cfDistribution = new cloudfront.Distribution(scope, 'CloudFrontDistribution', cfprops);\n  updateSecurityPolicy(cfDistribution);\n\n  // Extract the CfnBucketPolicy from the sourceBucket\n  const bucketPolicy = props.sourceBucket.policy as s3.BucketPolicy;\n  // the lack of a bucketPolicy means the bucket was imported from outside the stack so the lack of cfn_nag suppression is not an issue\n  if (bucketPolicy) {\n    addCfnSuppressRules(bucketPolicy, [\n      {\n        id: 'F16',\n        reason: `Public website bucket policy requires a wildcard principal`\n      }\n    ]);\n  }\n  return {\n    distribution: cfDistribution,\n    cloudfrontFunction,\n    loggingBucket: getLoggingBucketResponse.logBucket,\n    loggingBucketS3AccesssLogBucket: getLoggingBucketResponse.logBucketAccessLogBucket,\n    originAccessControl};\n}\n\nexport interface CloudFrontDistributionForMediaStoreResponse {\n  readonly distribution: cloudfront.Distribution,\n  readonly loggingBucket?: s3.Bucket,\n  readonly requestPolicy: cloudfront.OriginRequestPolicy,\n  readonly cloudfrontFunction?: cloudfront.Function\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function CloudFrontDistributionForMediaStore(scope: Construct,\n  mediaStoreContainer: mediastore.CfnContainer,\n  cloudFrontDistributionProps?: cloudfront.DistributionProps | any,\n  httpSecurityHeaders: boolean = true,\n  cloudFrontLoggingBucketProps?: s3.BucketProps,\n  responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps\n): CloudFrontDistributionForMediaStoreResponse {\n\n  let originRequestPolicy: cloudfront.OriginRequestPolicy;\n\n  const getLoggingBucketResponse = getLoggingBucket(scope, { cloudFrontDistributionProps, cloudFrontLoggingBucketProps });\n\n  if (cloudFrontDistributionProps\n    && cloudFrontDistributionProps.defaultBehavior\n    && cloudFrontDistributionProps.defaultBehavior.originRequestPolicy) {\n    originRequestPolicy = cloudFrontDistributionProps.defaultBehavior.originRequestPolicy;\n  } else {\n    const originRequestPolicyProps: cloudfront.OriginRequestPolicyProps = {\n      headerBehavior: {\n        behavior: 'whitelist',\n        headers: [\n          'Access-Control-Allow-Origin',\n          'Access-Control-Request-Method',\n          'Access-Control-Request-Header',\n          'Origin'\n        ]\n      },\n      queryStringBehavior: {\n        behavior: 'all'\n      },\n      cookieBehavior: {\n        behavior: 'none'\n      },\n      comment: 'Policy for Constructs CloudFrontDistributionForMediaStore',\n      originRequestPolicyName: `${cdk.Aws.STACK_NAME}-${cdk.Aws.REGION}-CloudFrontDistributionForMediaStore`\n    };\n\n    originRequestPolicy = new cloudfront.OriginRequestPolicy(scope, 'CloudfrontOriginRequestPolicy', originRequestPolicyProps);\n  }\n\n  const cloudfrontFunction = getCloudfrontFunction(httpSecurityHeaders, scope);\n\n  const defaultprops = DefaultCloudFrontDistributionForMediaStoreProps(\n    mediaStoreContainer,\n    getLoggingBucketResponse.logBucket,\n    originRequestPolicy,\n    httpSecurityHeaders,\n    cloudFrontDistributionProps?.customHeaders,\n    cloudfrontFunction,\n    responseHeadersPolicyProps ? new cloudfront.ResponseHeadersPolicy(scope, 'ResponseHeadersPolicy', responseHeadersPolicyProps) : undefined\n  );\n\n  let cfprops: cloudfront.DistributionProps;\n\n  cfprops = consolidateProps(defaultprops, cloudFrontDistributionProps);\n\n  // Create the CloudFront Distribution\n  const cfDistribution = new cloudfront.Distribution(scope, 'CloudFrontDistribution', cfprops);\n  updateSecurityPolicy(cfDistribution);\n\n  return { distribution: cfDistribution, loggingBucket: getLoggingBucketResponse.logBucket, requestPolicy: originRequestPolicy, cloudfrontFunction };\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function CloudFrontOriginAccessIdentity(scope: Construct, comment?: string) {\n  return new cloudfront.OriginAccessIdentity(scope, 'CloudFrontOriginAccessIdentity', {\n    comment: comment ? comment : `access-identity-${cdk.Aws.REGION}-${cdk.Aws.STACK_NAME}`\n  });\n}\n\ninterface GetLoggingBucketRequest {\n  readonly cloudFrontDistributionProps: cloudfront.DistributionProps | any,\n  readonly cloudFrontLoggingBucketProps?: s3.BucketProps,\n  readonly cloudFrontLoggingBucketS3AccessLogBucketProps?: s3.BucketProps,\n  readonly enableS3AccessLogs?: boolean\n}\ninterface GetLoggingBucketResponse {\n  logBucket?: s3.Bucket,\n  logBucketAccessLogBucket?: s3.Bucket\n}\n\nfunction getLoggingBucket(scope: Construct, props: GetLoggingBucketRequest): GetLoggingBucketResponse {\n  const isLoggingDisabled = props.cloudFrontDistributionProps?.enableLogging === false;\n  const userSuppliedLogBucket = props.cloudFrontDistributionProps?.logBucket;\n\n  if (userSuppliedLogBucket && props.cloudFrontLoggingBucketProps) {\n    throw Error('Either cloudFrontDistributionProps.logBucket or cloudFrontLoggingBucketProps can be set.');\n  }\n\n  let logBucket: s3.Bucket | undefined;\n  let logBuckeS3AccessLogBuckett: s3.Bucket | undefined;\n  if (isLoggingDisabled) {\n    logBucket = undefined;\n  } else if (userSuppliedLogBucket) {\n    logBucket = userSuppliedLogBucket;\n  } else {\n    const createBucketResponse = createCloudFrontLoggingBucket(\n      scope,\n      'CloudfrontLoggingBucket',\n      {\n        // Buckets used for CloudFront distribution logging require ACLs to be explicitly enabled, so we apply this objectOwnership\n        loggingBucketProps: consolidateProps(DefaultS3Props(), props.cloudFrontLoggingBucketProps, {\n          objectOwnership: s3.ObjectOwnership.OBJECT_WRITER\n        }),\n        s3AccessLogBucketProps: props.cloudFrontLoggingBucketS3AccessLogBucketProps,\n        enableS3AccessLogs: props.enableS3AccessLogs\n      });\n\n    logBucket = createBucketResponse.logBucket;\n    logBuckeS3AccessLogBuckett = createBucketResponse.s3AccessLogBucket;\n    const loggingBucketResource = logBucket.node.findChild('Resource') as s3.CfnBucket;\n    loggingBucketResource.addPropertyOverride('AccessControl', 'LogDeliveryWrite');\n  }\n  return {\n    logBucket,\n    logBucketAccessLogBucket: logBuckeS3AccessLogBuckett\n  };\n}\n\nfunction getCloudfrontFunction(httpSecurityHeaders: boolean, scope: Construct) {\n  return httpSecurityHeaders ? defaultCloudfrontFunction(scope) : undefined;\n}\n\nexport interface CloudFrontProps {\n  readonly insertHttpSecurityHeaders?: boolean;\n  readonly responseHeadersPolicyProps?: cloudfront.ResponseHeadersPolicyProps;\n}\n\nexport function CheckCloudFrontProps(propsObject: CloudFrontProps | any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (propsObject.insertHttpSecurityHeaders !== false && propsObject.responseHeadersPolicyProps?.securityHeadersBehavior) {\n    errorMessages += 'responseHeadersPolicyProps.securityHeadersBehavior can only be passed if httpSecurityHeaders is set to `false`.';\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/cloudwatch-log-group-helper.js

@@ -0,0 +1,54 @@
+"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.buildLogGroup = 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 cloudwatch_log_group_defaults_1 = require("./cloudwatch-log-group-defaults");
+const logs = require("aws-cdk-lib/aws-logs");
+const utils_1 = require("./utils");
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildLogGroup(scope, logGroupId, logGroupProps) {
+    let consolidatedLogGroupProps;
+    // Override user provided CW LogGroup props with the DefaultLogGroupProps
+    consolidatedLogGroupProps = (0, utils_1.consolidateProps)((0, cloudwatch_log_group_defaults_1.DefaultLogGroupProps)(), logGroupProps);
+    // Set the LogGroup Id
+    const adjustedLogGroupId = logGroupId ? logGroupId : 'CloudWatchLogGroup';
+    // Create the CW Log Group
+    const logGroup = new logs.LogGroup(scope, adjustedLogGroupId, consolidatedLogGroupProps);
+    // If required, suppress the Cfn Nag WARNINGS
+    if (consolidatedLogGroupProps.retention === logs.RetentionDays.INFINITE) {
+        (0, utils_1.addCfnSuppressRules)(logGroup, [
+            {
+                id: 'W86',
+                reason: 'Retention period for CloudWatchLogs LogGroups are set to \'Never Expire\' to preserve customer data indefinitely'
+            }
+        ]);
+    }
+    if (!consolidatedLogGroupProps.encryptionKey) {
+        (0, utils_1.addCfnSuppressRules)(logGroup, [
+            {
+                id: 'W84',
+                reason: 'By default CloudWatchLogs LogGroups data is encrypted using the CloudWatch server-side encryption keys (AWS Managed Keys)'
+            }
+        ]);
+    }
+    return logGroup;
+}
+exports.buildLogGroup = buildLogGroup;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+/**
+ *  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 cognito from 'aws-cdk-lib/aws-cognito';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Construct } from 'constructs';
+export interface CognitoOptions {
+    readonly identitypool: cognito.CfnIdentityPool;
+    readonly userpool: cognito.UserPool;
+    readonly userpoolclient: cognito.UserPoolClient;
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildUserPool(scope: Construct, userPoolProps?: cognito.UserPoolProps): cognito.UserPool;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildUserPoolClient(scope: Construct, userPool: cognito.UserPool, cognitoUserPoolClientProps?: cognito.UserPoolClientProps): cognito.UserPoolClient;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildIdentityPool(scope: Construct, userpool: cognito.UserPool, userpoolclient: cognito.UserPoolClient, identityPoolProps?: cognito.CfnIdentityPoolProps): cognito.CfnIdentityPool;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function setupCognitoForSearchService(scope: Construct, domainName: string, options: CognitoOptions): iam.Role;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+export declare function buildCognitoForSearchService(scope: Construct, domainName: string): [
+    cognito.UserPool,
+    cognito.UserPoolClient,
+    cognito.CfnIdentityPool,
+    iam.Role
+];