@digitraffic/common 2022.10.5

package/aws/infra/stack/stack-checking-aspect.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackCheckingAspect = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const stack_1 = require("./stack");
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+const change_case_1 = require("change-case");
+const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const MAX_CONCURRENCY_LIMIT = 100;
+const NODE_RUNTIME = aws_lambda_1.Runtime.NODEJS_14_X.name;
+var ResourceType;
+(function (ResourceType) {
+    ResourceType["stackName"] = "STACK_NAME";
+    ResourceType["reservedConcurrentConcurrency"] = "RESERVED_CONCURRENT_CONCURRENCY";
+    ResourceType["functionTimeout"] = "FUNCTION_TIMEOUT";
+    ResourceType["functionMemorySize"] = "FUNCTION_MEMORY_SIZE";
+    ResourceType["functionRuntime"] = "FUNCTION_RUNTIME";
+    ResourceType["functionName"] = "FUNCTION_NAME";
+    ResourceType["tagSolution"] = "TAG_SOLUTION";
+    ResourceType["bucketPublicity"] = "BUCKET_PUBLICITY";
+    ResourceType["resourcePath"] = "RESOURCE_PATH";
+    ResourceType["queueEncryption"] = "QUEUE_ENCRYPTION";
+    ResourceType["logGroupRetention"] = "LOG_GROUP_RETENTION";
+})(ResourceType || (ResourceType = {}));
+class StackCheckingAspect {
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    static create(stack) {
+        return new StackCheckingAspect(stack.configuration);
+    }
+    visit(node) {
+        //console.info("visiting class " + node.constructor.name);
+        this.checkStack(node);
+        this.checkFunction(node);
+        this.checkTags(node);
+        this.checkBucket(node);
+        this.checkResourceCasing(node);
+        this.checkQueueEncryption(node);
+        this.checkLogGroupRetention(node);
+    }
+    isWhitelisted(key) {
+        return this?.configuration?.whitelistedResources?.some(wl => {
+            return key.matchAll(new RegExp(wl, 'g'));
+        });
+    }
+    addAnnotation(node, key, message, isError = true) {
+        const resourceKey = `${node.node.path}/${key}`;
+        const isWhiteListed = this.isWhitelisted(resourceKey);
+        const annotationMessage = `${resourceKey}:${message}`;
+        // error && whitelisted -> warning
+        // warning && whitelisted -> nothing
+        if (isError && !isWhiteListed) {
+            aws_cdk_lib_1.Annotations.of(node).addError(annotationMessage);
+        }
+        else if ((!isError && !isWhiteListed) || (isError && isWhiteListed)) {
+            aws_cdk_lib_1.Annotations.of(node).addWarning(annotationMessage);
+        }
+    }
+    checkStack(node) {
+        if (node instanceof stack_1.DigitrafficStack) {
+            if ((node.stackName.includes('Test') || node.stackName.includes('Tst')) && node.configuration?.production) {
+                this.addAnnotation(node, ResourceType.stackName, 'Production is set for Test-stack');
+            }
+            if ((node.stackName.includes('Prod') || node.stackName.includes('Prd')) && !node.configuration?.production) {
+                this.addAnnotation(node, ResourceType.stackName, 'Production is not set for Production-stack');
+            }
+        }
+    }
+    checkFunction(node) {
+        if (node instanceof aws_lambda_1.CfnFunction) {
+            if (!node.reservedConcurrentExecutions) {
+                this.addAnnotation(node, ResourceType.reservedConcurrentConcurrency, 'Function must have reservedConcurrentConcurrency');
+            }
+            else if (node.reservedConcurrentExecutions > MAX_CONCURRENCY_LIMIT) {
+                this.addAnnotation(node, ResourceType.reservedConcurrentConcurrency, 'Function reservedConcurrentConcurrency too high!');
+            }
+            if (!node.timeout) {
+                this.addAnnotation(node, ResourceType.functionTimeout, 'Function must have timeout');
+            }
+            if (!node.memorySize) {
+                this.addAnnotation(node, ResourceType.functionMemorySize, 'Function must have memorySize');
+            }
+            if (node.runtime !== NODE_RUNTIME) {
+                this.addAnnotation(node, ResourceType.functionRuntime, 'wrong runtime ' + node.runtime);
+            }
+            if (this.configuration?.shortName && node.functionName && node.functionName.indexOf(this.configuration.shortName) !== 0) {
+                this.addAnnotation(node, ResourceType.functionName, 'Function name does not begin with ' + this.configuration.shortName);
+            }
+        }
+    }
+    checkTags(node) {
+        if (node instanceof aws_cdk_lib_1.Stack) {
+            if (!node.tags.tagValues()[stack_1.SOLUTION_KEY]) {
+                this.addAnnotation(node, ResourceType.tagSolution, 'Solution tag is missing');
+            }
+        }
+    }
+    checkBucket(node) {
+        if (node instanceof aws_s3_1.CfnBucket) {
+            const c = node.publicAccessBlockConfiguration;
+            if (c) {
+                if (!c.blockPublicAcls || !c.blockPublicPolicy || !c.ignorePublicAcls || !c.restrictPublicBuckets) {
+                    this.addAnnotation(node, ResourceType.bucketPublicity, 'Check bucket publicity');
+                }
+            }
+        }
+    }
+    static isValidPath(path) {
+        // if path includes . or { check only the trailing part of path
+        if (path.includes('.')) {
+            return this.isValidPath(path.split('.')[0]);
+        }
+        if (path.includes('{')) {
+            return this.isValidPath(path.split('{')[0]);
+        }
+        return (0, change_case_1.paramCase)(path) === path;
+    }
+    static isValidQueryString(name) {
+        return (0, change_case_1.snakeCase)(name) === name;
+    }
+    checkResourceCasing(node) {
+        if (node instanceof aws_apigateway_1.CfnResource) {
+            if (!StackCheckingAspect.isValidPath(node.pathPart)) {
+                this.addAnnotation(node, ResourceType.resourcePath, 'Path part should be in kebab-case');
+            }
+        }
+        else if (node instanceof aws_apigateway_1.CfnMethod) {
+            const integration = node.integration;
+            if (integration && integration.requestParameters) {
+                Object.keys(integration.requestParameters).forEach(key => {
+                    const split = key.split('.');
+                    const type = split[2];
+                    const name = split[3];
+                    if (type === 'querystring' && !StackCheckingAspect.isValidQueryString(name)) {
+                        this.addAnnotation(node, name, 'Querystring should be in snake_case');
+                    }
+                });
+            }
+        }
+    }
+    checkQueueEncryption(node) {
+        if (node instanceof aws_sqs_1.CfnQueue) {
+            if (!node.kmsMasterKeyId) {
+                this.addAnnotation(node, ResourceType.queueEncryption, 'Queue must have encryption enabled');
+            }
+        }
+    }
+    checkLogGroupRetention(node) {
+        if (node instanceof aws_logs_1.LogRetention) {
+            const child = node.node.defaultChild;
+            const retention = child._cfnProperties.RetentionInDays;
+            if (!retention) {
+                this.addAnnotation(node, ResourceType.logGroupRetention, 'Log group must define log group retention');
+            }
+        }
+    }
+}
+exports.StackCheckingAspect = StackCheckingAspect;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-checking-aspect.js","sourceRoot":"","sources":["../../../../src/aws/infra/stack/stack-checking-aspect.ts"],"names":[],"mappings":"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","sourcesContent":["import {Annotations, IAspect, Stack} from \"aws-cdk-lib\";\nimport {CfnFunction, Runtime} from 'aws-cdk-lib/aws-lambda';\nimport {CfnBucket} from \"aws-cdk-lib/aws-s3\";\nimport {DigitrafficStack, SOLUTION_KEY, StackConfiguration} from \"./stack\";\nimport {IConstruct} from \"constructs\";\nimport {CfnMethod, CfnResource} from \"aws-cdk-lib/aws-apigateway\";\nimport {paramCase, snakeCase} from \"change-case\";\nimport {CfnQueue} from \"aws-cdk-lib/aws-sqs\";\nimport {LogRetention} from \"aws-cdk-lib/aws-logs\";\nimport IntegrationProperty = CfnMethod.IntegrationProperty;\n\nconst MAX_CONCURRENCY_LIMIT = 100;\nconst NODE_RUNTIME = Runtime.NODEJS_14_X.name;\n\nenum ResourceType {\n    stackName = \"STACK_NAME\",\n    reservedConcurrentConcurrency = \"RESERVED_CONCURRENT_CONCURRENCY\",\n    functionTimeout = \"FUNCTION_TIMEOUT\",\n    functionMemorySize = \"FUNCTION_MEMORY_SIZE\",\n    functionRuntime = \"FUNCTION_RUNTIME\",\n    functionName = \"FUNCTION_NAME\",\n    tagSolution = \"TAG_SOLUTION\",\n    bucketPublicity = \"BUCKET_PUBLICITY\",\n    resourcePath = \"RESOURCE_PATH\",\n    queueEncryption = \"QUEUE_ENCRYPTION\",\n    logGroupRetention = \"LOG_GROUP_RETENTION\",\n}\n\nexport class StackCheckingAspect implements IAspect {\n    private readonly configuration?: StackConfiguration;\n\n    constructor(configuration?: StackConfiguration) {\n        this.configuration = configuration;\n    }\n\n    static create(stack: DigitrafficStack) {\n        return new StackCheckingAspect(stack.configuration);\n    }\n\n    public visit(node: IConstruct): void {\n        //console.info(\"visiting class \" + node.constructor.name);\n\n        this.checkStack(node);\n        this.checkFunction(node);\n        this.checkTags(node);\n        this.checkBucket(node);\n        this.checkResourceCasing(node);\n        this.checkQueueEncryption(node);\n        this.checkLogGroupRetention(node);\n    }\n\n    private isWhitelisted(key: string) {\n        return this?.configuration?.whitelistedResources?.some(wl => {\n            return key.matchAll(new RegExp(wl, 'g'));\n        });\n    }\n\n    private addAnnotation(node: IConstruct, key: ResourceType | string, message: string, isError = true) {\n        const resourceKey = `${node.node.path}/${key}`;\n        const isWhiteListed = this.isWhitelisted(resourceKey);\n        const annotationMessage = `${resourceKey}:${message}`;\n\n        // error && whitelisted -> warning\n        // warning && whitelisted -> nothing\n        if (isError && !isWhiteListed) {\n            Annotations.of(node).addError(annotationMessage);\n        } else if ((!isError && !isWhiteListed) || (isError && isWhiteListed)) {\n            Annotations.of(node).addWarning(annotationMessage);\n        }\n    }\n\n    private checkStack(node: IConstruct) {\n        if (node instanceof DigitrafficStack) {\n            if ((node.stackName.includes('Test') || node.stackName.includes('Tst')) && node.configuration?.production) {\n                this.addAnnotation(node, ResourceType.stackName, 'Production is set for Test-stack');\n            }\n\n            if ((node.stackName.includes('Prod') || node.stackName.includes('Prd')) && !node.configuration?.production) {\n                this.addAnnotation(node, ResourceType.stackName, 'Production is not set for Production-stack');\n            }\n        }\n    }\n\n    private checkFunction(node: IConstruct) {\n        if (node instanceof CfnFunction) {\n            if (!node.reservedConcurrentExecutions) {\n                this.addAnnotation(node, ResourceType.reservedConcurrentConcurrency, 'Function must have reservedConcurrentConcurrency');\n            } else if (node.reservedConcurrentExecutions > MAX_CONCURRENCY_LIMIT) {\n                this.addAnnotation(node, ResourceType.reservedConcurrentConcurrency, 'Function reservedConcurrentConcurrency too high!');\n            }\n\n            if (!node.timeout) {\n                this.addAnnotation(node, ResourceType.functionTimeout, 'Function must have timeout');\n            }\n\n            if (!node.memorySize) {\n                this.addAnnotation(node, ResourceType.functionMemorySize, 'Function must have memorySize');\n            }\n\n            if (node.runtime !== NODE_RUNTIME) {\n                this.addAnnotation(node, ResourceType.functionRuntime,'wrong runtime ' + node.runtime);\n            }\n\n            if (this.configuration?.shortName && node.functionName && node.functionName.indexOf(this.configuration.shortName) !== 0) {\n                this.addAnnotation(node, ResourceType.functionName, 'Function name does not begin with ' + this.configuration.shortName);\n            }\n        }\n    }\n\n    private checkTags(node: IConstruct) {\n        if (node instanceof Stack) {\n            if (!node.tags.tagValues()[SOLUTION_KEY]) {\n                this.addAnnotation(node, ResourceType.tagSolution, 'Solution tag is missing');\n            }\n        }\n    }\n\n    private checkBucket(node: IConstruct) {\n        if (node instanceof CfnBucket) {\n            const c = node.publicAccessBlockConfiguration as CfnBucket.PublicAccessBlockConfigurationProperty;\n\n            if (c) {\n                if (!c.blockPublicAcls || !c.blockPublicPolicy || !c.ignorePublicAcls || !c.restrictPublicBuckets) {\n                    this.addAnnotation(node, ResourceType.bucketPublicity, 'Check bucket publicity');\n                }\n            }\n        }\n    }\n\n    private static isValidPath(path: string): boolean {\n        // if path includes . or { check only the trailing part of path\n        if (path.includes('.')) {\n            return this.isValidPath(path.split('.')[0]);\n        }\n\n        if (path.includes('{')) {\n            return this.isValidPath(path.split('{')[0]);\n        }\n\n        return paramCase(path) === path;\n    }\n\n    private static isValidQueryString(name: string) {\n        return snakeCase(name) === name;\n    }\n\n    private checkResourceCasing(node: IConstruct) {\n        if (node instanceof CfnResource) {\n            if (!StackCheckingAspect.isValidPath(node.pathPart)) {\n                this.addAnnotation(node, ResourceType.resourcePath, 'Path part should be in kebab-case');\n            }\n        } else if (node instanceof CfnMethod) {\n            const integration = node.integration as IntegrationProperty;\n\n            if (integration && integration.requestParameters) {\n                Object.keys(integration.requestParameters).forEach(key => {\n                    const split = key.split('.');\n                    const type = split[2];\n                    const name = split[3];\n\n                    if (type === 'querystring' && !StackCheckingAspect.isValidQueryString(name)) {\n                        this.addAnnotation(node, name, 'Querystring should be in snake_case');\n                    }\n                });\n            }\n        }\n    }\n\n    private checkQueueEncryption(node: IConstruct) {\n        if (node instanceof CfnQueue) {\n            if (!node.kmsMasterKeyId) {\n                this.addAnnotation(node, ResourceType.queueEncryption, 'Queue must have encryption enabled');\n            }\n        }\n    }\n\n    private checkLogGroupRetention(node: IConstruct) {\n        if (node instanceof LogRetention) {\n            const child = node.node.defaultChild as unknown as Record<string, Record<string, string>>;\n            const retention = child._cfnProperties.RetentionInDays;\n\n            if (!retention) {\n                this.addAnnotation(node, ResourceType.logGroupRetention, 'Log group must define log group retention');\n            }\n        }\n    }\n}\n"]}

package/aws/infra/stack/stack.d.ts

@@ -0,0 +1,41 @@
+import { Stack, StackProps } from "aws-cdk-lib";
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { ISecurityGroup } from "aws-cdk-lib/aws-ec2/lib/security-group";
+import { ITopic } from "aws-cdk-lib/aws-sns";
+import { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { Function } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+import { TrafficType } from "../../../types/traffictype";
+import { DBLambdaEnvironment } from "./lambda-configs";
+export declare const SOLUTION_KEY = "Solution";
+export declare const SSM_KEY_WARNING_TOPIC: string;
+export declare const SSM_KEY_ALARM_TOPIC: string;
+export declare type StackConfiguration = {
+    readonly shortName?: string;
+    readonly secretId?: string;
+    readonly alarmTopicArn: string;
+    readonly warningTopicArn: string;
+    readonly enableCanaries: boolean;
+    readonly logsDestinationArn?: string;
+    readonly vpcId?: string;
+    readonly lambdaDbSgId?: string;
+    readonly privateSubnetIds?: string[];
+    readonly availabilityZones?: string[];
+    readonly trafficType: TrafficType;
+    readonly production: boolean;
+    readonly stackProps: StackProps;
+    readonly whitelistedResources?: string[];
+};
+export declare class DigitrafficStack extends Stack {
+    readonly vpc: IVpc;
+    readonly lambdaDbSg: ISecurityGroup;
+    readonly alarmTopic: ITopic;
+    readonly warningTopic: ITopic;
+    readonly secret: ISecret;
+    readonly configuration: StackConfiguration;
+    constructor(scope: Construct, id: string, configuration: StackConfiguration);
+    addAspects(): void;
+    createLambdaEnvironment(): DBLambdaEnvironment;
+    createDefaultLambdaEnvironment(dbApplication: string): DBLambdaEnvironment;
+    grantSecret(...lambdas: Function[]): void;
+}

package/aws/infra/stack/stack.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitrafficStack = exports.SSM_KEY_ALARM_TOPIC = exports.SSM_KEY_WARNING_TOPIC = exports.SOLUTION_KEY = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_sns_1 = require("aws-cdk-lib/aws-sns");
+const aws_ssm_1 = require("aws-cdk-lib/aws-ssm");
+const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
+const stack_checking_aspect_1 = require("./stack-checking-aspect");
+const SSM_ROOT = '/digitraffic';
+exports.SOLUTION_KEY = 'Solution';
+const MONITORING_ROOT = '/monitoring';
+exports.SSM_KEY_WARNING_TOPIC = `${SSM_ROOT}${MONITORING_ROOT}/warning-topic`;
+exports.SSM_KEY_ALARM_TOPIC = `${SSM_ROOT}${MONITORING_ROOT}/alarm-topic`;
+class DigitrafficStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, configuration) {
+        super(scope, id, configuration.stackProps);
+        this.configuration = configuration;
+        if (configuration.secretId) {
+            this.secret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, 'Secret', configuration.secretId);
+        }
+        // VPC reference construction requires vpcId and availability zones
+        // private subnets are used in Lambda configuration
+        if (configuration.vpcId) {
+            this.vpc = aws_ec2_1.Vpc.fromVpcAttributes(this, 'vpc', {
+                vpcId: configuration.vpcId,
+                privateSubnetIds: configuration.privateSubnetIds,
+                availabilityZones: configuration.availabilityZones,
+            });
+        }
+        // security group that allows Lambda database access
+        if (configuration.lambdaDbSgId) {
+            this.lambdaDbSg = aws_ec2_1.SecurityGroup.fromSecurityGroupId(this, 'LambdaDbSG', configuration.lambdaDbSgId);
+        }
+        this.alarmTopic = aws_sns_1.Topic.fromTopicArn(this, 'AlarmTopic', aws_ssm_1.StringParameter.fromStringParameterName(this, 'AlarmTopicParam', exports.SSM_KEY_ALARM_TOPIC).stringValue);
+        this.warningTopic = aws_sns_1.Topic.fromTopicArn(this, 'WarningTopic', aws_ssm_1.StringParameter.fromStringParameterName(this, 'WarningTopicParam', exports.SSM_KEY_WARNING_TOPIC).stringValue);
+        this.addAspects();
+    }
+    addAspects() {
+        aws_cdk_lib_1.Aspects.of(this).add(stack_checking_aspect_1.StackCheckingAspect.create(this));
+    }
+    createLambdaEnvironment() {
+        return this.createDefaultLambdaEnvironment(this.configuration.shortName);
+    }
+    createDefaultLambdaEnvironment(dbApplication) {
+        return this.configuration.secretId ? {
+            SECRET_ID: this.configuration.secretId,
+            DB_APPLICATION: dbApplication,
+        } : {
+            DB_APPLICATION: dbApplication,
+        };
+    }
+    grantSecret(...lambdas) {
+        lambdas.forEach((l) => this.secret.grantRead(l));
+    }
+}
+exports.DigitrafficStack = DigitrafficStack;
+//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/stack/subscription.d.ts

@@ -0,0 +1,17 @@
+import { CfnSubscriptionFilter } from 'aws-cdk-lib/aws-logs';
+import { Function } from 'aws-cdk-lib/aws-lambda';
+import { DigitrafficStack } from "./stack";
+import { Construct } from "constructs";
+import { MonitoredFunction } from "./monitoredfunction";
+/**
+ * Creates a subscription filter that subscribes to a Lambda Log Group and delivers the logs to another destination.
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-subscriptionfilter.html
+ * @param lambda The Lambda function, needed to create a dependency
+ * @param lambdaName The Lambda name from which the Log Group name is derived
+ * @param logDestinationArn Destination for streamed logs
+ * @param stack CloudFormation stack
+ */
+export declare function createSubscription(lambda: Function, lambdaName: string, logDestinationArn: string | undefined, stack: Construct): CfnSubscriptionFilter | undefined;
+export declare class DigitrafficLogSubscriptions {
+    constructor(stack: DigitrafficStack, ...lambdas: MonitoredFunction[]);
+}

package/aws/infra/stack/subscription.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitrafficLogSubscriptions = exports.createSubscription = void 0;
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+/**
+ * Creates a subscription filter that subscribes to a Lambda Log Group and delivers the logs to another destination.
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-subscriptionfilter.html
+ * @param lambda The Lambda function, needed to create a dependency
+ * @param lambdaName The Lambda name from which the Log Group name is derived
+ * @param logDestinationArn Destination for streamed logs
+ * @param stack CloudFormation stack
+ */
+function createSubscription(lambda, lambdaName, logDestinationArn, stack) {
+    if (logDestinationArn == undefined) {
+        return undefined;
+    }
+    const filter = new aws_logs_1.CfnSubscriptionFilter(stack, `${lambdaName}LogsSubscription`, {
+        logGroupName: `/aws/lambda/${lambdaName}`,
+        filterPattern: '',
+        destinationArn: logDestinationArn,
+    });
+    filter.node.addDependency(lambda);
+    return filter;
+}
+exports.createSubscription = createSubscription;
+class DigitrafficLogSubscriptions {
+    constructor(stack, ...lambdas) {
+        if (stack.configuration.logsDestinationArn) {
+            lambdas.forEach(lambda => {
+                const filter = new aws_logs_1.CfnSubscriptionFilter(stack, `${lambda.givenName}LogsSubscription`, {
+                    logGroupName: `/aws/lambda/${lambda.givenName}`,
+                    filterPattern: '',
+                    destinationArn: stack.configuration.logsDestinationArn,
+                });
+                filter.node.addDependency(lambda);
+            });
+        }
+    }
+}
+exports.DigitrafficLogSubscriptions = DigitrafficLogSubscriptions;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2NyaXB0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2F3cy9pbmZyYS9zdGFjay9zdWJzY3JpcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbURBQTJEO0FBTTNEOzs7Ozs7O0dBT0c7QUFDSCxTQUFnQixrQkFBa0IsQ0FBQyxNQUFnQixFQUFFLFVBQWtCLEVBQUUsaUJBQXFDLEVBQUUsS0FBZ0I7SUFDNUgsSUFBSSxpQkFBaUIsSUFBSSxTQUFTLEVBQUU7UUFDaEMsT0FBTyxTQUFTLENBQUM7S0FDcEI7SUFDRCxNQUFNLE1BQU0sR0FBRyxJQUFJLGdDQUFxQixDQUFDLEtBQUssRUFBRSxHQUFHLFVBQVUsa0JBQWtCLEVBQUU7UUFDN0UsWUFBWSxFQUFFLGVBQWUsVUFBVSxFQUFFO1FBQ3pDLGFBQWEsRUFBRSxFQUFFO1FBQ2pCLGNBQWMsRUFBRSxpQkFBaUI7S0FDcEMsQ0FBQyxDQUFDO0lBRUgsTUFBTSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFbEMsT0FBTyxNQUFNLENBQUM7QUFDbEIsQ0FBQztBQWJELGdEQWFDO0FBRUQsTUFBYSwyQkFBMkI7SUFDcEMsWUFBWSxLQUF1QixFQUFFLEdBQUcsT0FBNEI7UUFDaEUsSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDLGtCQUFrQixFQUFFO1lBQ3hDLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUU7Z0JBQ3JCLE1BQU0sTUFBTSxHQUFHLElBQUksZ0NBQXFCLENBQUMsS0FBSyxFQUFFLEdBQUcsTUFBTSxDQUFDLFNBQVMsa0JBQWtCLEVBQUU7b0JBQ25GLFlBQVksRUFBRSxlQUFlLE1BQU0sQ0FBQyxTQUFTLEVBQUU7b0JBQy9DLGFBQWEsRUFBRSxFQUFFO29CQUNqQixjQUFjLEVBQUUsS0FBSyxDQUFDLGFBQWEsQ0FBQyxrQkFBNEI7aUJBQ25FLENBQUMsQ0FBQztnQkFFSCxNQUFNLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUN0QyxDQUFDLENBQUMsQ0FBQztTQUNOO0lBQ0wsQ0FBQztDQUNKO0FBZEQsa0VBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NmblN1YnNjcmlwdGlvbkZpbHRlcn0gZnJvbSAnYXdzLWNkay1saWIvYXdzLWxvZ3MnO1xuaW1wb3J0IHtGdW5jdGlvbn0gZnJvbSAnYXdzLWNkay1saWIvYXdzLWxhbWJkYSc7XG5pbXBvcnQge0RpZ2l0cmFmZmljU3RhY2t9IGZyb20gXCIuL3N0YWNrXCI7XG5pbXBvcnQge0NvbnN0cnVjdH0gZnJvbSBcImNvbnN0cnVjdHNcIjtcbmltcG9ydCB7TW9uaXRvcmVkRnVuY3Rpb259IGZyb20gXCIuL21vbml0b3JlZGZ1bmN0aW9uXCI7XG5cbi8qKlxuICogQ3JlYXRlcyBhIHN1YnNjcmlwdGlvbiBmaWx0ZXIgdGhhdCBzdWJzY3JpYmVzIHRvIGEgTGFtYmRhIExvZyBHcm91cCBhbmQgZGVsaXZlcnMgdGhlIGxvZ3MgdG8gYW5vdGhlciBkZXN0aW5hdGlvbi5cbiAqIGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9BV1NDbG91ZEZvcm1hdGlvbi9sYXRlc3QvVXNlckd1aWRlL2F3cy1yZXNvdXJjZS1sb2dzLXN1YnNjcmlwdGlvbmZpbHRlci5odG1sXG4gKiBAcGFyYW0gbGFtYmRhIFRoZSBMYW1iZGEgZnVuY3Rpb24sIG5lZWRlZCB0byBjcmVhdGUgYSBkZXBlbmRlbmN5XG4gKiBAcGFyYW0gbGFtYmRhTmFtZSBUaGUgTGFtYmRhIG5hbWUgZnJvbSB3aGljaCB0aGUgTG9nIEdyb3VwIG5hbWUgaXMgZGVyaXZlZFxuICogQHBhcmFtIGxvZ0Rlc3RpbmF0aW9uQXJuIERlc3RpbmF0aW9uIGZvciBzdHJlYW1lZCBsb2dzXG4gKiBAcGFyYW0gc3RhY2sgQ2xvdWRGb3JtYXRpb24gc3RhY2tcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVN1YnNjcmlwdGlvbihsYW1iZGE6IEZ1bmN0aW9uLCBsYW1iZGFOYW1lOiBzdHJpbmcsIGxvZ0Rlc3RpbmF0aW9uQXJuOiBzdHJpbmcgfCB1bmRlZmluZWQsIHN0YWNrOiBDb25zdHJ1Y3QpOiBDZm5TdWJzY3JpcHRpb25GaWx0ZXIgfCB1bmRlZmluZWQge1xuICAgIGlmIChsb2dEZXN0aW5hdGlvbkFybiA9PSB1bmRlZmluZWQpIHtcbiAgICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICB9XG4gICAgY29uc3QgZmlsdGVyID0gbmV3IENmblN1YnNjcmlwdGlvbkZpbHRlcihzdGFjaywgYCR7bGFtYmRhTmFtZX1Mb2dzU3Vic2NyaXB0aW9uYCwge1xuICAgICAgICBsb2dHcm91cE5hbWU6IGAvYXdzL2xhbWJkYS8ke2xhbWJkYU5hbWV9YCxcbiAgICAgICAgZmlsdGVyUGF0dGVybjogJycsXG4gICAgICAgIGRlc3RpbmF0aW9uQXJuOiBsb2dEZXN0aW5hdGlvbkFybixcbiAgICB9KTtcblxuICAgIGZpbHRlci5ub2RlLmFkZERlcGVuZGVuY3kobGFtYmRhKTtcblxuICAgIHJldHVybiBmaWx0ZXI7XG59XG5cbmV4cG9ydCBjbGFzcyBEaWdpdHJhZmZpY0xvZ1N1YnNjcmlwdGlvbnMge1xuICAgIGNvbnN0cnVjdG9yKHN0YWNrOiBEaWdpdHJhZmZpY1N0YWNrLCAuLi5sYW1iZGFzOiBNb25pdG9yZWRGdW5jdGlvbltdKSB7XG4gICAgICAgIGlmIChzdGFjay5jb25maWd1cmF0aW9uLmxvZ3NEZXN0aW5hdGlvbkFybikge1xuICAgICAgICAgICAgbGFtYmRhcy5mb3JFYWNoKGxhbWJkYSA9PiB7XG4gICAgICAgICAgICAgICAgY29uc3QgZmlsdGVyID0gbmV3IENmblN1YnNjcmlwdGlvbkZpbHRlcihzdGFjaywgYCR7bGFtYmRhLmdpdmVuTmFtZX1Mb2dzU3Vic2NyaXB0aW9uYCwge1xuICAgICAgICAgICAgICAgICAgICBsb2dHcm91cE5hbWU6IGAvYXdzL2xhbWJkYS8ke2xhbWJkYS5naXZlbk5hbWV9YCxcbiAgICAgICAgICAgICAgICAgICAgZmlsdGVyUGF0dGVybjogJycsXG4gICAgICAgICAgICAgICAgICAgIGRlc3RpbmF0aW9uQXJuOiBzdGFjay5jb25maWd1cmF0aW9uLmxvZ3NEZXN0aW5hdGlvbkFybiBhcyBzdHJpbmcsXG4gICAgICAgICAgICAgICAgfSk7XG5cbiAgICAgICAgICAgICAgICBmaWx0ZXIubm9kZS5hZGREZXBlbmRlbmN5KGxhbWJkYSk7XG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfVxuICAgIH1cbn1cbiJdfQ==

package/aws/infra/usage-plans.d.ts

@@ -0,0 +1,15 @@
+import { IApiKey, RestApi } from 'aws-cdk-lib/aws-apigateway';
+/**
+ * Creates an usage plan for a REST API with a single API key
+ * @param api The REST API
+ * @param apiKeyId Id for the API key, this is a surrogate id for CDK, not displayed anywhere
+ * @param apiKeyName Name for the API key, this is displayed in the AWS Console
+ * @deprecated Creates randomized API key names, use createDefaultUsagePlan instead
+ */
+export declare function createUsagePlan(api: RestApi, apiKeyId: string, apiKeyName: string): IApiKey;
+/**
+ * Creates a default usage plan for a REST API with a single API key
+ * @param api The REST API
+ * @param apiName Name of the api. Will generate key: apiName + ' API Key' and plan: apiName + ' API Usage Plan'
+ */
+export declare function createDefaultUsagePlan(api: RestApi, apiName: string): IApiKey;

package/aws/infra/usage-plans.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultUsagePlan = exports.createUsagePlan = void 0;
+/**
+ * Creates an usage plan for a REST API with a single API key
+ * @param api The REST API
+ * @param apiKeyId Id for the API key, this is a surrogate id for CDK, not displayed anywhere
+ * @param apiKeyName Name for the API key, this is displayed in the AWS Console
+ * @deprecated Creates randomized API key names, use createDefaultUsagePlan instead
+ */
+function createUsagePlan(api, apiKeyId, apiKeyName) {
+    const apiKey = api.addApiKey(apiKeyId);
+    const plan = api.addUsagePlan(apiKeyName, {
+        name: apiKeyName,
+    });
+    plan.addApiStage({
+        stage: api.deploymentStage,
+    });
+    plan.addApiKey(apiKey);
+    return apiKey;
+}
+exports.createUsagePlan = createUsagePlan;
+/**
+ * Creates a default usage plan for a REST API with a single API key
+ * @param api The REST API
+ * @param apiName Name of the api. Will generate key: apiName + ' API Key' and plan: apiName + ' API Usage Plan'
+ */
+function createDefaultUsagePlan(api, apiName) {
+    const apiKeyName = apiName + ' API Key';
+    const usagePlanName = apiName + ' API Usage Plan';
+    const apiKey = api.addApiKey(apiKeyName, { apiKeyName: apiKeyName });
+    const plan = api.addUsagePlan(usagePlanName, {
+        name: usagePlanName,
+    });
+    plan.addApiStage({
+        stage: api.deploymentStage,
+    });
+    plan.addApiKey(apiKey);
+    return apiKey;
+}
+exports.createDefaultUsagePlan = createDefaultUsagePlan;
+//# sourceMappingURL=data:application/json;base64,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

package/aws/runtime/apikey.d.ts

@@ -0,0 +1,2 @@
+import { APIGateway } from "aws-sdk";
+export declare function getApiKeyFromAPIGateway(keyId: string): Promise<APIGateway.Types.ApiKey>;

package/aws/runtime/apikey.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiKeyFromAPIGateway = void 0;
+const aws_sdk_1 = require("aws-sdk");
+function getApiKeyFromAPIGateway(keyId) {
+    const agw = new aws_sdk_1.APIGateway();
+    return agw.getApiKey({
+        apiKey: keyId,
+        includeValue: true,
+    }).promise();
+}
+exports.getApiKeyFromAPIGateway = getApiKeyFromAPIGateway;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpa2V5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9ydW50aW1lL2FwaWtleS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxQ0FBbUM7QUFFbkMsU0FBZ0IsdUJBQXVCLENBQUMsS0FBYTtJQUNqRCxNQUFNLEdBQUcsR0FBRyxJQUFJLG9CQUFVLEVBQUUsQ0FBQztJQUM3QixPQUFPLEdBQUcsQ0FBQyxTQUFTLENBQUM7UUFDakIsTUFBTSxFQUFFLEtBQUs7UUFDYixZQUFZLEVBQUUsSUFBSTtLQUNyQixDQUFDLENBQUMsT0FBTyxFQUFFLENBQUM7QUFDakIsQ0FBQztBQU5ELDBEQU1DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBUElHYXRld2F5fSBmcm9tIFwiYXdzLXNka1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0QXBpS2V5RnJvbUFQSUdhdGV3YXkoa2V5SWQ6IHN0cmluZyk6IFByb21pc2U8QVBJR2F0ZXdheS5UeXBlcy5BcGlLZXk+IHtcbiAgICBjb25zdCBhZ3cgPSBuZXcgQVBJR2F0ZXdheSgpO1xuICAgIHJldHVybiBhZ3cuZ2V0QXBpS2V5KHtcbiAgICAgICAgYXBpS2V5OiBrZXlJZCxcbiAgICAgICAgaW5jbHVkZVZhbHVlOiB0cnVlLFxuICAgIH0pLnByb21pc2UoKTtcbn1cbiJdfQ==

package/aws/runtime/digitraffic-integration-response.d.ts

@@ -0,0 +1,8 @@
+import { IntegrationResponse } from "aws-cdk-lib/aws-apigateway";
+import { MediaType } from "../types/mediatypes";
+export declare abstract class DigitrafficIntegrationResponse {
+    static ok(mediaType: MediaType): IntegrationResponse;
+    static badRequest(mediaType?: MediaType): IntegrationResponse;
+    static notImplemented(mediaType?: MediaType): IntegrationResponse;
+    static create(statusCode: string, mediaType: MediaType): IntegrationResponse;
+}

package/aws/runtime/digitraffic-integration-response.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitrafficIntegrationResponse = void 0;
+const mediatypes_1 = require("../types/mediatypes");
+const response_1 = require("../infra/api/response");
+class DigitrafficIntegrationResponse {
+    static ok(mediaType) {
+        return this.create("200", mediaType);
+    }
+    static badRequest(mediaType) {
+        return this.create("400", mediaType ?? mediatypes_1.MediaType.TEXT_PLAIN);
+    }
+    static notImplemented(mediaType) {
+        return this.create("501", mediaType ?? mediatypes_1.MediaType.TEXT_PLAIN);
+    }
+    static create(statusCode, mediaType) {
+        return {
+            statusCode,
+            responseTemplates: {
+                [mediaType]: response_1.RESPONSE_DEFAULT_LAMBDA,
+            },
+        };
+    }
+}
+exports.DigitrafficIntegrationResponse = DigitrafficIntegrationResponse;
+//# sourceMappingURL=data:application/json;base64,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

package/aws/runtime/messaging.d.ts

@@ -0,0 +1,10 @@
+import { SNS } from "aws-sdk";
+/**
+ * Utility function for publishing SNS messages.
+ * Made because using *await* with AWS APIs doesn't require calling promise() but nothing works if it isn't called.
+ * Retries a single time in case of failure.
+ * @param message
+ * @param topicArn
+ * @param sns
+ */
+export declare function snsPublish(message: string, topicArn: string, sns: SNS): Promise<void>;

package/aws/runtime/messaging.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snsPublish = void 0;
+/**
+ * Utility function for publishing SNS messages.
+ * Made because using *await* with AWS APIs doesn't require calling promise() but nothing works if it isn't called.
+ * Retries a single time in case of failure.
+ * @param message
+ * @param topicArn
+ * @param sns
+ */
+async function snsPublish(message, topicArn, sns) {
+    const publishParams = {
+        Message: message,
+        TopicArn: topicArn,
+    };
+    try {
+        await sns.publish(publishParams).promise();
+    }
+    catch (error) {
+        console.error('method=snsPublish error, retrying', error);
+        try {
+            await sns.publish(publishParams).promise();
+        }
+        catch (e2) {
+            console.error('method=snsPublish error after retry', e2);
+        }
+    }
+}
+exports.snsPublish = snsPublish;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9ydW50aW1lL21lc3NhZ2luZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7OztHQU9HO0FBQ0ksS0FBSyxVQUFVLFVBQVUsQ0FBQyxPQUFlLEVBQUUsUUFBZ0IsRUFBRSxHQUFRO0lBQ3hFLE1BQU0sYUFBYSxHQUFHO1FBQ2xCLE9BQU8sRUFBRSxPQUFPO1FBQ2hCLFFBQVEsRUFBRSxRQUFRO0tBQ3JCLENBQUM7SUFDRixJQUFJO1FBQ0EsTUFBTSxHQUFHLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDO0tBQzlDO0lBQUMsT0FBTyxLQUFLLEVBQUU7UUFDWixPQUFPLENBQUMsS0FBSyxDQUFDLG1DQUFtQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQzFELElBQUk7WUFDQSxNQUFNLEdBQUcsQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUM7U0FDOUM7UUFBQyxPQUFPLEVBQUUsRUFBRTtZQUNULE9BQU8sQ0FBQyxLQUFLLENBQUMscUNBQXFDLEVBQUUsRUFBRSxDQUFDLENBQUM7U0FDNUQ7S0FDSjtBQUNMLENBQUM7QUFmRCxnQ0FlQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7U05TfSBmcm9tIFwiYXdzLXNka1wiO1xuXG4vKipcbiAqIFV0aWxpdHkgZnVuY3Rpb24gZm9yIHB1Ymxpc2hpbmcgU05TIG1lc3NhZ2VzLlxuICogTWFkZSBiZWNhdXNlIHVzaW5nICphd2FpdCogd2l0aCBBV1MgQVBJcyBkb2Vzbid0IHJlcXVpcmUgY2FsbGluZyBwcm9taXNlKCkgYnV0IG5vdGhpbmcgd29ya3MgaWYgaXQgaXNuJ3QgY2FsbGVkLlxuICogUmV0cmllcyBhIHNpbmdsZSB0aW1lIGluIGNhc2Ugb2YgZmFpbHVyZS5cbiAqIEBwYXJhbSBtZXNzYWdlXG4gKiBAcGFyYW0gdG9waWNBcm5cbiAqIEBwYXJhbSBzbnNcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHNuc1B1Ymxpc2gobWVzc2FnZTogc3RyaW5nLCB0b3BpY0Fybjogc3RyaW5nLCBzbnM6IFNOUykge1xuICAgIGNvbnN0IHB1Ymxpc2hQYXJhbXMgPSB7XG4gICAgICAgIE1lc3NhZ2U6IG1lc3NhZ2UsXG4gICAgICAgIFRvcGljQXJuOiB0b3BpY0FybixcbiAgICB9O1xuICAgIHRyeSB7XG4gICAgICAgIGF3YWl0IHNucy5wdWJsaXNoKHB1Ymxpc2hQYXJhbXMpLnByb21pc2UoKTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgICBjb25zb2xlLmVycm9yKCdtZXRob2Q9c25zUHVibGlzaCBlcnJvciwgcmV0cnlpbmcnLCBlcnJvcik7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICBhd2FpdCBzbnMucHVibGlzaChwdWJsaXNoUGFyYW1zKS5wcm9taXNlKCk7XG4gICAgICAgIH0gY2F0Y2ggKGUyKSB7XG4gICAgICAgICAgICBjb25zb2xlLmVycm9yKCdtZXRob2Q9c25zUHVibGlzaCBlcnJvciBhZnRlciByZXRyeScsIGUyKTtcbiAgICAgICAgfVxuICAgIH1cbn1cbiJdfQ==

package/aws/runtime/s3.d.ts

@@ -0,0 +1,2 @@
+import { S3 } from "aws-sdk";
+export declare function uploadToS3<Body extends S3.Body | undefined>(bucketName: string, body: Body, objectName: string, cannedAcl?: string, contentType?: string): Promise<void>;

package/aws/runtime/s3.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadToS3 = void 0;
+const aws_sdk_1 = require("aws-sdk");
+async function uploadToS3(bucketName, body, objectName, cannedAcl, contentType) {
+    const s3 = new aws_sdk_1.S3();
+    try {
+        await doUpload(s3, bucketName, body, objectName, cannedAcl, contentType);
+    }
+    catch (error) {
+        console.warn('method=uploadToS3 retrying upload to bucket %s', bucketName);
+        try {
+            await doUpload(s3, bucketName, body, objectName, cannedAcl, contentType);
+        }
+        catch (e2) {
+            console.error('method=uploadToS3 failed retrying upload to bucket %s', bucketName);
+        }
+    }
+}
+exports.uploadToS3 = uploadToS3;
+function doUpload(s3, bucketName, body, filename, cannedAcl, contentType) {
+    return s3.upload({
+        Bucket: bucketName,
+        Body: body,
+        Key: filename,
+        ACL: cannedAcl,
+        ContentType: contentType,
+    }).promise();
+}
+//# sourceMappingURL=data:application/json;base64,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