@bitblit/ratchet-epsilon-deployment 4.0.85-alpha

package/dist/cjs/deployment/cdk/epsilon-stack-util.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpsilonStackUtil = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+class EpsilonStackUtil {
+    constructor() { }
+    static toEnvironmentVariables(input) {
+        const rval = [];
+        input.forEach((inval) => {
+            Object.keys(inval).forEach((k) => {
+                rval.push({
+                    name: k,
+                    value: ratchet_common_1.StringRatchet.safeString(inval[k]),
+                });
+            });
+        });
+        return rval;
+    }
+    static createDefaultPolicyStatementList(props, backgroundLambdaSqs, backgroundLambdaSns, interApiSns) {
+        const rval = (props.additionalPolicyStatements || []).concat([
+            new aws_iam_1.PolicyStatement({
+                effect: aws_iam_1.Effect.ALLOW,
+                actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],
+                resources: ['arn:aws:logs:*:*:*'],
+            }),
+            new aws_iam_1.PolicyStatement({
+                effect: aws_iam_1.Effect.ALLOW,
+                actions: ['ses:SendEmail', 'ses:SendRawEmail'],
+                resources: ['arn:aws:ses:*'],
+            }),
+            new aws_iam_1.PolicyStatement({
+                effect: aws_iam_1.Effect.ALLOW,
+                actions: ['sqs:*'],
+                resources: [backgroundLambdaSqs.queueArn],
+            }),
+            new aws_iam_1.PolicyStatement({
+                effect: aws_iam_1.Effect.ALLOW,
+                actions: ['sns:*'],
+                resources: [backgroundLambdaSns.topicArn, interApiSns.topicArn],
+            }),
+            new aws_iam_1.PolicyStatement({
+                effect: aws_iam_1.Effect.ALLOW,
+                actions: ['batch:*'],
+                resources: ['*'],
+            }),
+        ]);
+        return rval;
+    }
+}
+exports.EpsilonStackUtil = EpsilonStackUtil;
+EpsilonStackUtil.ALLOW_ECS = new aws_iam_1.PolicyStatement({
+    effect: aws_iam_1.Effect.ALLOW,
+    actions: ['ecs:*'],
+    resources: ['*'],
+});
+EpsilonStackUtil.ALLOW_ECR = new aws_iam_1.PolicyStatement({
+    effect: aws_iam_1.Effect.ALLOW,
+    actions: ['ecr:BatchCheckLayerAvailability', 'ecr:BatchGetImage', 'ecr:GetDownloadUrlForLayer', 'ecr:GetAuthorizationToken'],
+    resources: ['*'],
+});
+EpsilonStackUtil.ALLOW_RESTRICTED_LOGS = new aws_iam_1.PolicyStatement({
+    effect: aws_iam_1.Effect.ALLOW,
+    actions: ['logs:CreateLogStream', 'logs:PutLogEvents', 'logs:DescribeLogStreams', 'logs:CreateLogGroup'],
+    resources: ['*'],
+});
+EpsilonStackUtil.ECS_POLICY_STATEMENTS = [
+    EpsilonStackUtil.ALLOW_ECS,
+    EpsilonStackUtil.ALLOW_ECR,
+    EpsilonStackUtil.ALLOW_RESTRICTED_LOGS,
+];

package/dist/cjs/deployment/cdk/epsilon-website-stack-props.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpsilonWebsiteStackPropsRoute53Handling = void 0;
+var EpsilonWebsiteStackPropsRoute53Handling;
+(function (EpsilonWebsiteStackPropsRoute53Handling) {
+    EpsilonWebsiteStackPropsRoute53Handling["Update"] = "Update";
+    EpsilonWebsiteStackPropsRoute53Handling["DoNotUpdate"] = "DoNotUpdate";
+})(EpsilonWebsiteStackPropsRoute53Handling = exports.EpsilonWebsiteStackPropsRoute53Handling || (exports.EpsilonWebsiteStackPropsRoute53Handling = {}));

package/dist/cjs/deployment/cdk/epsilon-website-stack.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpsilonWebsiteStack = void 0;
+const tslib_1 = require("tslib");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const epsilon_website_stack_props_1 = require("./epsilon-website-stack-props");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class EpsilonWebsiteStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        var _a;
+        super(scope, id, props);
+        const originAccessId = new aws_cloudfront_1.OriginAccessIdentity(this, id + 'OriginAccessId');
+        const websiteBucket = new aws_s3_1.Bucket(this, id + 'DeployBucket', {
+            bucketName: props.targetBucketName,
+            versioned: false,
+            publicReadAccess: false,
+            encryption: aws_s3_1.BucketEncryption.S3_MANAGED,
+        });
+        const extraBucketAndSource = (props.simpleAdditionalMappings || []).map((eb) => {
+            const nextBucket = new aws_s3_1.Bucket(this, eb.bucketName + 'DeployBucket', {
+                bucketName: eb.bucketName,
+                versioned: false,
+                publicReadAccess: false,
+                encryption: aws_s3_1.BucketEncryption.S3_MANAGED,
+            });
+            const nextBS = {
+                bucket: nextBucket,
+                sourceConfig: {
+                    s3OriginSource: {
+                        s3BucketSource: nextBucket,
+                        originAccessIdentity: originAccessId,
+                    },
+                    behaviors: [
+                        {
+                            pathPattern: eb.pathPattern,
+                            isDefaultBehavior: false,
+                            compress: true,
+                            defaultTtl: aws_cdk_lib_1.Duration.seconds(1),
+                            minTtl: aws_cdk_lib_1.Duration.seconds(1),
+                            maxTtl: aws_cdk_lib_1.Duration.seconds(1),
+                            forwardedValues: {
+                                queryString: false,
+                            },
+                        },
+                    ],
+                },
+            };
+            return nextBS;
+        });
+        const assetSource = {
+            s3OriginSource: {
+                s3BucketSource: websiteBucket,
+                originAccessIdentity: originAccessId,
+            },
+            behaviors: [
+                {
+                    isDefaultBehavior: true,
+                    compress: true,
+                    defaultTtl: aws_cdk_lib_1.Duration.seconds(1),
+                    minTtl: aws_cdk_lib_1.Duration.seconds(1),
+                    maxTtl: aws_cdk_lib_1.Duration.seconds(1),
+                    forwardedValues: {
+                        queryString: false,
+                    },
+                },
+            ],
+        };
+        const apiSource = {
+            customOriginSource: {
+                domainName: props.apiDomainName,
+                originProtocolPolicy: aws_cloudfront_1.OriginProtocolPolicy.HTTPS_ONLY,
+            },
+            behaviors: [
+                {
+                    compress: true,
+                    forwardedValues: {
+                        queryString: true,
+                        cookies: {
+                            forward: 'whitelist',
+                            whitelistedNames: ['idToken'],
+                        },
+                        headers: ['Accept', 'Referer', 'Authorization', 'Content-Type'],
+                    },
+                    pathPattern: 'graphql',
+                    defaultTtl: aws_cdk_lib_1.Duration.seconds(0),
+                    maxTtl: aws_cdk_lib_1.Duration.seconds(0),
+                    minTtl: aws_cdk_lib_1.Duration.seconds(0),
+                    allowedMethods: aws_cloudfront_1.CloudFrontAllowedMethods.ALL,
+                    cachedMethods: aws_cloudfront_1.CloudFrontAllowedCachedMethods.GET_HEAD,
+                },
+            ],
+        };
+        const distributionProps = {
+            httpVersion: aws_cloudfront_1.HttpVersion.HTTP2,
+            defaultRootObject: 'index.html',
+            originConfigs: [assetSource, apiSource, ...extraBucketAndSource.map((s) => s.sourceConfig)],
+            errorConfigurations: [
+                {
+                    errorCode: 404,
+                    errorCachingMinTtl: 300,
+                    responseCode: 200,
+                    responsePagePath: '/index.html',
+                },
+                {
+                    errorCode: 403,
+                    errorCachingMinTtl: 300,
+                    responseCode: 200,
+                    responsePagePath: '/index.html',
+                },
+            ],
+            priceClass: aws_cloudfront_1.PriceClass.PRICE_CLASS_ALL,
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            viewerCertificate: {
+                aliases: props.cloudFrontDomainNames,
+                props: {
+                    acmCertificateArn: props.cloudFrontHttpsCertificateArn,
+                    sslSupportMethod: 'sni-only',
+                },
+            },
+        };
+        const cloudfrontDistro = new aws_cloudfront_1.CloudFrontWebDistribution(this, id + 'CloudfrontDistro', distributionProps);
+        if ((props === null || props === void 0 ? void 0 : props.route53Handling) === epsilon_website_stack_props_1.EpsilonWebsiteStackPropsRoute53Handling.Update) {
+            if ((_a = props === null || props === void 0 ? void 0 : props.cloudFrontDomainNames) === null || _a === void 0 ? void 0 : _a.length) {
+                for (let i = 0; i < props.cloudFrontDomainNames.length; i++) {
+                    const domain = new aws_route53_1.RecordSet(this, id + 'DomainName-' + props.cloudFrontDomainNames[i], {
+                        recordType: aws_route53_1.RecordType.A,
+                        recordName: props.cloudFrontDomainNames[i],
+                        target: {
+                            aliasTarget: new aws_route53_targets_1.CloudFrontTarget(cloudfrontDistro),
+                        },
+                        zone: aws_route53_1.HostedZone.fromLookup(this, id, { domainName: EpsilonWebsiteStack.extractApexDomain(props.cloudFrontDomainNames[i]) }),
+                    });
+                }
+            }
+        }
+        new aws_s3_deployment_1.BucketDeployment(this, id + 'SiteDeploy', {
+            sources: props.pathsToAssets.map((inPath) => aws_s3_deployment_1.Source.asset(path_1.default.resolve(inPath))),
+            destinationBucket: websiteBucket,
+            distribution: cloudfrontDistro,
+            distributionPaths: ['/*'],
+        });
+    }
+    static extractApexDomain(domainName) {
+        const pieces = ratchet_common_1.StringRatchet.trimToEmpty(domainName).split('.');
+        if (pieces.length < 2) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Not a valid domain name : %s', domainName);
+        }
+        return pieces[pieces.length - 2] + '.' + pieces[pieces.length - 1];
+    }
+}
+exports.EpsilonWebsiteStack = EpsilonWebsiteStack;

package/dist/cjs/deployment/cdk/simple-additional-s3-website-mapping.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build/ratchet-epsilon-deployment-info"), exports);
+tslib_1.__exportStar(require("./deployment/cdk/epsilon-api-stack-props"), exports);
+tslib_1.__exportStar(require("./deployment/cdk/epsilon-api-stack"), exports);
+tslib_1.__exportStar(require("./deployment/cdk/epsilon-stack-util"), exports);
+tslib_1.__exportStar(require("./deployment/cdk/epsilon-website-stack-props"), exports);
+tslib_1.__exportStar(require("./deployment/cdk/epsilon-website-stack"), exports);
+tslib_1.__exportStar(require("./deployment/cdk/simple-additional-s3-website-mapping"), exports);

package/dist/es/build/ratchet-epsilon-deployment-info.js

@@ -0,0 +1,14 @@
+export class RatchetEpsilonDeploymentInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '85',
+            hash: '7b2bd151314408f02450300b0d5fb0e008d38deb',
+            branch: 'alpha-2023-03-14-1',
+            tag: 'alpha-2023-03-14-1',
+            timeBuiltISO: '2023-03-14T20:58:46-0700',
+            notes: '',
+        };
+        return val;
+    }
+}

package/dist/es/deployment/cdk/epsilon-api-stack-props.js

@@ -0,0 +1 @@
+export {};

package/dist/es/deployment/cdk/epsilon-api-stack.js

@@ -0,0 +1,178 @@
+import { Duration, Lazy, Size, Stack } from 'aws-cdk-lib';
+import { CfnComputeEnvironment, CfnJobDefinition, CfnJobQueue, } from 'aws-cdk-lib/aws-batch';
+import { DockerImageCode, DockerImageFunction, FunctionUrlAuthType, HttpMethod } from 'aws-cdk-lib/aws-lambda';
+import { CfnInstanceProfile, ManagedPolicy, PolicyDocument, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { Topic } from 'aws-cdk-lib/aws-sns';
+import { Queue } from 'aws-cdk-lib/aws-sqs';
+import { LambdaSubscription } from 'aws-cdk-lib/aws-sns-subscriptions';
+import { Rule, Schedule } from 'aws-cdk-lib/aws-events';
+import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets';
+import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { EpsilonStackUtil } from './epsilon-stack-util';
+import { RatchetEpsilonDeploymentInfo } from '../../build/ratchet-epsilon-deployment-info';
+export class EpsilonApiStack extends Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const dockerImageAsset = new DockerImageAsset(this, id + 'DockerImage', {
+            directory: props.dockerFileFolder,
+            file: props.dockerFileName,
+        });
+        const dockerImageCode = DockerImageCode.fromImageAsset(props.dockerFileFolder, { file: props.dockerFileName });
+        const notificationTopic = new Topic(this, id + 'WorkNotificationTopic');
+        const workQueue = new Queue(this, id + 'WorkQueue', {
+            fifo: true,
+            retentionPeriod: Duration.hours(8),
+            visibilityTimeout: Duration.minutes(5),
+            contentBasedDeduplication: true,
+            ...props,
+        });
+        const interApiGenericEventTopic = new Topic(this, id + 'InterApiTopic');
+        const epsilonEnv = {
+            EPSILON_AWS_REGION: StringRatchet.safeString(Stack.of(this).region),
+            EPSILON_AWS_AVAILABILITY_ZONES: StringRatchet.safeString(JSON.stringify(Stack.of(this).availabilityZones)),
+            EPSILON_BACKGROUND_SQS_QUEUE_URL: StringRatchet.safeString(workQueue.queueUrl),
+            EPSILON_BACKGROUND_SNS_TOPIC_ARN: StringRatchet.safeString(notificationTopic.topicArn),
+            EPSILON_INTER_API_EVENT_TOPIC_ARN: StringRatchet.safeString(interApiGenericEventTopic.topicArn),
+            EPSILON_LIB_BUILD_HASH: StringRatchet.safeString(RatchetEpsilonDeploymentInfo.buildInformation().hash),
+            EPSILON_LIB_BUILD_TIME: StringRatchet.safeString(RatchetEpsilonDeploymentInfo.buildInformation().timeBuiltISO),
+            EPSILON_LIB_BUILD_BRANCH_OR_TAG: StringRatchet.safeString(RatchetEpsilonDeploymentInfo.buildInformation().branch || RatchetEpsilonDeploymentInfo.buildInformation().tag),
+            EPSILON_LIB_BUILD_VERSION: StringRatchet.safeString(RatchetEpsilonDeploymentInfo.buildInformation().version),
+        };
+        const env = Object.assign({}, props.extraEnvironmentalVars || {}, epsilonEnv);
+        const ecsRole = new Role(this, id + 'AwsEcsRole', {
+            assumedBy: new ServicePrincipal('ec2.amazonaws.com'),
+            inlinePolicies: {
+                root: new PolicyDocument({
+                    statements: EpsilonStackUtil.ECS_POLICY_STATEMENTS,
+                }),
+            },
+        });
+        const ecsInstanceProfile = new CfnInstanceProfile(this, id + 'EcsInstanceProfile', {
+            path: '/',
+            roles: [ecsRole.roleName],
+        });
+        const jobRole = new Role(this, id + 'AwsBatchRole', {
+            assumedBy: new ServicePrincipal('ecs-tasks.amazonaws.com'),
+            managedPolicies: [ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole')],
+            inlinePolicies: {
+                root: new PolicyDocument({
+                    statements: EpsilonStackUtil.createDefaultPolicyStatementList(props, workQueue, notificationTopic, interApiGenericEventTopic),
+                }),
+            },
+        });
+        const compEnvProps = {
+            replaceComputeEnvironment: false,
+            computeResources: {
+                minvCpus: 0,
+                maxvCpus: 16,
+                instanceTypes: ['optimal'],
+                instanceRole: ecsInstanceProfile.attrArn,
+                ec2KeyPair: props.batchInstancesEc2KeyPairName,
+                type: 'EC2',
+                subnets: props.vpcSubnetIds.map((s) => 'subnet-' + s),
+                securityGroupIds: props.lambdaSecurityGroupIds.map((s) => 'sg-' + s),
+                allocationStrategy: 'BEST_FIT',
+            },
+            serviceRole: 'arn:aws:iam::' + props.env.account + ':role/AWSBatchServiceRole',
+            type: 'MANAGED',
+            state: 'ENABLED',
+        };
+        const compEnv = new CfnComputeEnvironment(this, id + 'ComputeEnv', compEnvProps);
+        const batchJobQueueProps = {
+            state: 'ENABLED',
+            priority: 1,
+            computeEnvironmentOrder: [
+                {
+                    computeEnvironment: compEnv.attrComputeEnvironmentArn,
+                    order: 1,
+                },
+            ],
+            tags: {
+                tagsKey: id,
+            },
+        };
+        const batchJobQueue = new CfnJobQueue(this, id + 'BatchJobQueue', batchJobQueueProps);
+        const batchEnvVars = EpsilonStackUtil.toEnvironmentVariables([
+            env,
+            props.extraEnvironmentalVars || {},
+            {
+                EPSILON_RUNNING_IN_AWS_BATCH: true,
+            },
+        ]);
+        const jobProps = {
+            type: 'container',
+            platformCapabilities: ['EC2'],
+            containerProperties: {
+                mountPoints: [],
+                volumes: [],
+                memory: 4294,
+                privileged: false,
+                jobRoleArn: jobRole.roleArn,
+                readonlyRootFilesystem: false,
+                vcpus: 1,
+                image: dockerImageAsset.imageUri,
+                command: ['Ref::taskName', 'Ref::taskData', 'Ref::traceId', 'Ref::traceDepth'],
+                environment: batchEnvVars,
+            },
+        };
+        const jobDef = new CfnJobDefinition(this, id + 'JobDefinition', jobProps);
+        const lambdaRole = new Role(this, 'customRole', {
+            roleName: id + 'LambdaCustomRole',
+            assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
+            managedPolicies: [ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole')],
+            inlinePolicies: {
+                root: new PolicyDocument({
+                    statements: EpsilonStackUtil.createDefaultPolicyStatementList(props, workQueue, notificationTopic, interApiGenericEventTopic),
+                }),
+            },
+        });
+        env['EPSILON_AWS_BATCH_JOB_DEFINITION_ARN'] = jobDef.ref;
+        env['EPSILON_AWS_BATCH_JOB_QUEUE_ARN'] = batchJobQueue.ref;
+        this.webHandler = new DockerImageFunction(this, id + 'Web', {
+            retryAttempts: 2,
+            memorySize: props.webMemorySizeMb || 128,
+            ephemeralStorageSize: Size.mebibytes(512),
+            timeout: Duration.seconds(props.webTimeoutSeconds || 20),
+            code: dockerImageCode,
+            role: lambdaRole,
+            environment: env,
+        });
+        if (props?.webLambdaPingMinutes && props.webLambdaPingMinutes > 0) {
+            const rule = new Rule(this, id + 'WebKeepaliveRule', {
+                schedule: Schedule.rate(Duration.minutes(Math.ceil(props.webLambdaPingMinutes))),
+            });
+            rule.addTarget(new LambdaFunction(this.webHandler));
+        }
+        const fnUrl = this.webHandler.addFunctionUrl({
+            authType: FunctionUrlAuthType.NONE,
+            cors: {
+                allowedOrigins: ['*'],
+                allowedHeaders: ['Content-Type', 'X-Amz-Date', 'Authorization', 'X-Api-Key'],
+                allowedMethods: [HttpMethod.ALL],
+                allowCredentials: true,
+            },
+        });
+        this.backgroundHandler = new DockerImageFunction(this, id + 'Background', {
+            retryAttempts: 2,
+            memorySize: props.backgroundMemorySizeMb || 3000,
+            ephemeralStorageSize: Size.mebibytes(512),
+            timeout: Duration.seconds(props.backgroundTimeoutSeconds || 900),
+            code: dockerImageCode,
+            role: lambdaRole,
+            environment: env,
+        });
+        notificationTopic.addSubscription(new LambdaSubscription(this.backgroundHandler));
+        interApiGenericEventTopic.addSubscription(new LambdaSubscription(this.backgroundHandler));
+        const rule = new Rule(this, id + 'CronRule', {
+            schedule: Schedule.rate(Duration.minutes(1)),
+        });
+        rule.addTarget(new LambdaFunction(this.backgroundHandler));
+        this.apiDomain = Lazy.uncachedString({
+            produce: (context) => {
+                const resolved = context.resolve(fnUrl.url);
+                return { 'Fn::Select': [2, { 'Fn::Split': ['/', resolved] }] };
+            },
+        });
+    }
+}

package/dist/es/deployment/cdk/epsilon-stack-util.js

@@ -0,0 +1,67 @@
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { Effect, PolicyStatement } from 'aws-cdk-lib/aws-iam';
+export class EpsilonStackUtil {
+    constructor() { }
+    static toEnvironmentVariables(input) {
+        const rval = [];
+        input.forEach((inval) => {
+            Object.keys(inval).forEach((k) => {
+                rval.push({
+                    name: k,
+                    value: StringRatchet.safeString(inval[k]),
+                });
+            });
+        });
+        return rval;
+    }
+    static createDefaultPolicyStatementList(props, backgroundLambdaSqs, backgroundLambdaSns, interApiSns) {
+        const rval = (props.additionalPolicyStatements || []).concat([
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],
+                resources: ['arn:aws:logs:*:*:*'],
+            }),
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: ['ses:SendEmail', 'ses:SendRawEmail'],
+                resources: ['arn:aws:ses:*'],
+            }),
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: ['sqs:*'],
+                resources: [backgroundLambdaSqs.queueArn],
+            }),
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: ['sns:*'],
+                resources: [backgroundLambdaSns.topicArn, interApiSns.topicArn],
+            }),
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: ['batch:*'],
+                resources: ['*'],
+            }),
+        ]);
+        return rval;
+    }
+}
+EpsilonStackUtil.ALLOW_ECS = new PolicyStatement({
+    effect: Effect.ALLOW,
+    actions: ['ecs:*'],
+    resources: ['*'],
+});
+EpsilonStackUtil.ALLOW_ECR = new PolicyStatement({
+    effect: Effect.ALLOW,
+    actions: ['ecr:BatchCheckLayerAvailability', 'ecr:BatchGetImage', 'ecr:GetDownloadUrlForLayer', 'ecr:GetAuthorizationToken'],
+    resources: ['*'],
+});
+EpsilonStackUtil.ALLOW_RESTRICTED_LOGS = new PolicyStatement({
+    effect: Effect.ALLOW,
+    actions: ['logs:CreateLogStream', 'logs:PutLogEvents', 'logs:DescribeLogStreams', 'logs:CreateLogGroup'],
+    resources: ['*'],
+});
+EpsilonStackUtil.ECS_POLICY_STATEMENTS = [
+    EpsilonStackUtil.ALLOW_ECS,
+    EpsilonStackUtil.ALLOW_ECR,
+    EpsilonStackUtil.ALLOW_RESTRICTED_LOGS,
+];

package/dist/es/deployment/cdk/epsilon-website-stack-props.js

@@ -0,0 +1,5 @@
+export var EpsilonWebsiteStackPropsRoute53Handling;
+(function (EpsilonWebsiteStackPropsRoute53Handling) {
+    EpsilonWebsiteStackPropsRoute53Handling["Update"] = "Update";
+    EpsilonWebsiteStackPropsRoute53Handling["DoNotUpdate"] = "DoNotUpdate";
+})(EpsilonWebsiteStackPropsRoute53Handling || (EpsilonWebsiteStackPropsRoute53Handling = {}));