@digitraffic/common 2022.11.22-1 → 2022.11.23-test

package/dist/aws/infra/api/integration.d.ts

@@ -0,0 +1,21 @@
+import { IntegrationResponse, LambdaIntegration } from "aws-cdk-lib/aws-apigateway";
+import { IFunction } from "aws-cdk-lib/aws-lambda";
+import { MediaType } from "../../types/mediatypes";
+type ParameterType = 'path' | 'querystring';
+interface ApiParameter {
+    type: ParameterType;
+    name: string;
+}
+export declare class DigitrafficIntegration {
+    readonly lambda: IFunction;
+    readonly mediaType: MediaType;
+    readonly parameters: ApiParameter[];
+    constructor(lambda: IFunction, mediaType?: MediaType);
+    addPathParameter(...names: string[]): DigitrafficIntegration;
+    addQueryParameter(...names: string[]): DigitrafficIntegration;
+    build(): LambdaIntegration;
+    createRequestParameters(): Record<string, string>;
+    createRequestTemplates(): Record<string, string>;
+    createResponses(): IntegrationResponse[];
+}
+export {};

package/dist/aws/infra/api/response.d.ts

@@ -0,0 +1,22 @@
+import apigateway = require('aws-cdk-lib/aws-apigateway');
+import { MediaType } from "../../types/mediatypes";
+/**
+ * This is velocity-script, that assumes the response to be LambdaResponse(status and body).
+ * It will always return the body and status, but if status in something else than 200 OK the content-type
+ * will be overridden to text/plain. (it's assumed, that lambda will return error text).
+ *
+ * If fileName is set, then Content-Disposition-header will be set to use it
+ */
+export declare const RESPONSE_DEFAULT_LAMBDA = "#set($inputRoot = $input.path('$'))\n$inputRoot.body\n#if ($inputRoot.status != 200)\n#set ($context.responseOverride.status = $inputRoot.status)\n#set ($context.responseOverride.header.Content-Type = 'text/plain')\n#end\n#set ($context.responseOverride.header.Access-Control-Allow-Origin = '*')\n#if (\"$!inputRoot.fileName\" != \"\")\n#set ($disposition = 'attachment; filename=\"FN\"')\n#set ($context.responseOverride.header.Content-Disposition = $disposition.replaceAll('FN', $inputRoot.fileName))\n#end\n";
+export declare const MessageModel: {
+    contentType: MediaType;
+    modelName: string;
+    schema: apigateway.JsonSchema;
+};
+export declare const NotFoundResponse: string;
+export declare const BadRequestResponseTemplate: Record<string, string>;
+export declare const NotFoundResponseTemplate: Record<string, string>;
+export declare const XmlResponseTemplate: Record<string, string>;
+export declare const SvgResponseTemplate: Record<string, string>;
+export declare const InternalServerErrorResponseTemplate: Record<string, string>;
+export declare function createResponses<T>(key: MediaType, value: T): Record<string, T>;

package/dist/aws/infra/api/responses.d.ts

@@ -0,0 +1,39 @@
+import { LambdaIntegration, MethodResponse, IntegrationResponse, PassthroughBehavior } from "aws-cdk-lib/aws-apigateway";
+import { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import { IModel } from "aws-cdk-lib/aws-apigateway/lib/model";
+import { MediaType } from "../../types/mediatypes";
+export declare const RESPONSE_200_OK: IntegrationResponse;
+export declare const RESPONSE_400_BAD_REQUEST: IntegrationResponse;
+export declare const RESPONSE_500_SERVER_ERROR: IntegrationResponse;
+export declare const RESPONSE_CORS_INTEGRATION: {
+    responseParameters: {
+        "method.response.header.Access-Control-Allow-Origin": string;
+    };
+};
+export declare const RESPONSE_404_NOT_FOUND: {
+    statusCode: string;
+    selectionPattern: string;
+    responseTemplates: Record<string, string>;
+};
+export declare function methodResponse(status: string, contentType: MediaType, model: IModel, parameters?: Record<string, boolean>): MethodResponse;
+export declare function corsMethod(response: MethodResponse): MethodResponse;
+interface IntegrationOptions {
+    requestParameters?: {
+        [dest: string]: string;
+    };
+    requestTemplates?: {
+        [contentType: string]: string;
+    };
+    responses?: IntegrationResponse[];
+    disableCors?: boolean;
+    xml?: boolean;
+    passthroughBehavior?: PassthroughBehavior;
+}
+/**
+ * Creates a default Lambda integration for a REST API resource _root_
+ * @param lambdaFunction The Lambda function
+ * @param options Options
+ */
+export declare function defaultIntegration(lambdaFunction: AWSFunction, options?: IntegrationOptions): LambdaIntegration;
+export declare function getResponse(response: IntegrationResponse, options?: IntegrationOptions): IntegrationResponse;
+export {};

package/dist/aws/infra/api/static-integration.d.ts

@@ -0,0 +1,15 @@
+import { MockIntegration, Resource } from "aws-cdk-lib/aws-apigateway";
+import { MediaType } from "../../types/mediatypes";
+/**
+ * Static integration, that returns the given response with given mediaType from given resource.
+ *
+ * @param resource
+ * @param mediaType
+ * @param response
+ */
+export declare class DigitrafficStaticIntegration extends MockIntegration {
+    constructor(resource: Resource, mediaType: MediaType, response: string, enableCors?: boolean, apiKeyRequired?: boolean);
+    static json<K>(resource: Resource, response: K, enableCors?: boolean, apiKeyRequired?: boolean): DigitrafficStaticIntegration;
+    private static createIntegrationResponse;
+    private static createMethodResponse;
+}

package/dist/aws/infra/canaries/canary-alarm.d.ts

@@ -0,0 +1,6 @@
+import { Construct } from "constructs";
+import { CanaryParameters } from "./canary-parameters";
+import { Canary } from "@aws-cdk/aws-synthetics-alpha";
+export declare class CanaryAlarm {
+    constructor(stack: Construct, canary: Canary, params: CanaryParameters);
+}

package/dist/aws/infra/canaries/canary-keys.d.ts

@@ -0,0 +1,3 @@
+export declare const ENV_API_KEY = "apiKeyId";
+export declare const ENV_HOSTNAME = "hostname";
+export declare const ENV_SECRET = "secret";

package/dist/aws/infra/canaries/canary-parameters.d.ts

@@ -0,0 +1,18 @@
+import { Schedule } from "@aws-cdk/aws-synthetics-alpha";
+/** Optional env parameters for canary */
+type CanaryEnv = Record<string, string>;
+export type CanaryParameters = {
+    readonly name: string;
+    readonly schedule?: Schedule;
+    readonly secret?: string;
+    readonly handler: string;
+    readonly alarm?: {
+        readonly alarmName?: string;
+        readonly description?: string;
+        readonly evalutionPeriods?: number;
+        readonly threshold?: number;
+        readonly topicArn?: string;
+    };
+    readonly canaryEnv?: CanaryEnv;
+};
+export {};

package/dist/aws/infra/canaries/canary-role.d.ts

@@ -0,0 +1,6 @@
+import { Role } from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+export declare class DigitrafficCanaryRole extends Role {
+    constructor(stack: Construct, canaryName: string);
+    withDatabaseAccess(): DigitrafficCanaryRole;
+}

package/dist/aws/infra/canaries/canary.d.ts

@@ -0,0 +1,8 @@
+import { Canary } from "@aws-cdk/aws-synthetics-alpha";
+import { Role } from "aws-cdk-lib/aws-iam";
+import { CanaryParameters } from "./canary-parameters";
+import { Construct } from "constructs";
+import { LambdaEnvironment } from "../stack/lambda-configs";
+export declare class DigitrafficCanary extends Canary {
+    constructor(scope: Construct, canaryName: string, role: Role, params: CanaryParameters, environmentVariables: LambdaEnvironment);
+}

package/dist/aws/infra/canaries/database-canary.d.ts

@@ -0,0 +1,18 @@
+import { Role } from "aws-cdk-lib/aws-iam";
+import { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { CanaryParameters } from "./canary-parameters";
+import { DigitrafficCanary } from "./canary";
+import { DigitrafficStack } from "../stack/stack";
+export declare class DatabaseCanary extends DigitrafficCanary {
+    constructor(stack: DigitrafficStack, role: Role, secret: ISecret, params: CanaryParameters);
+    static create(stack: DigitrafficStack, role: Role, params: CanaryParameters): DatabaseCanary;
+    /**
+     *
+     * @param stack
+     * @param role
+     * @param name name of the typescipt file without -db -suffix. Max len is 10 char if @param canaryName is not given.
+     * @param params
+     * @param canaryName Optional name for canary if multiple canaries is made from same ${name}-db.ts canary file.
+     */
+    static createV2(stack: DigitrafficStack, role: Role, name: string, params?: Partial<CanaryParameters>, canaryName?: string): DatabaseCanary;
+}

package/dist/aws/infra/canaries/database-checker.d.ts

@@ -0,0 +1,33 @@
+import { Countable } from "../../../database/models";
+declare abstract class DatabaseCheck<T> {
+    readonly name: string;
+    readonly sql: string;
+    failed: boolean;
+    protected constructor(name: string, sql: string);
+    abstract check(value: T): void;
+}
+/**
+ * Checker for sql that checks the count.  Meaning that the
+ * sql must be structured as "select count(*) from <table> where <something>".
+ */
+export declare class DatabaseCountChecker {
+    readonly credentialsFunction: () => Promise<void>;
+    readonly checks: DatabaseCheck<Countable>[];
+    private constructor();
+    static createForProxy(): DatabaseCountChecker;
+    static createForRds(): DatabaseCountChecker;
+    /**
+     * Expect that the count is 1
+     */
+    expectOne(name: string, sql: string): this;
+    /**
+     * Expect that the count is 0
+     */
+    expectZero(name: string, sql: string): this;
+    /**
+     * Expect that the count is 1 or more
+     */
+    expectOneOrMore(name: string, sql: string): this;
+    expect(): Promise<string>;
+}
+export {};

package/dist/aws/infra/canaries/url-canary.d.ts

@@ -0,0 +1,16 @@
+import { Construct } from "constructs";
+import { CanaryParameters } from "./canary-parameters";
+import { Role } from "aws-cdk-lib/aws-iam";
+import { DigitrafficCanary } from "./canary";
+import { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { DigitrafficStack } from "../stack/stack";
+import { DigitrafficRestApi } from "../stack/rest_apis";
+export interface UrlCanaryParameters extends CanaryParameters {
+    readonly hostname: string;
+    readonly apiKeyId?: string;
+}
+export declare class UrlCanary extends DigitrafficCanary {
+    constructor(stack: Construct, role: Role, params: UrlCanaryParameters, secret?: ISecret);
+    static create(stack: DigitrafficStack, role: Role, publicApi: DigitrafficRestApi, params: Partial<UrlCanaryParameters>): UrlCanary;
+    static getApiKey(publicApi: DigitrafficRestApi): string | undefined;
+}

package/dist/aws/infra/canaries/url-checker.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+import { MediaType } from "../../types/mediatypes";
+import { FeatureCollection } from "geojson";
+export declare const API_KEY_HEADER = "x-api-key";
+type CheckerFunction = (Res: IncomingMessage) => void;
+type JsonCheckerFunction<T> = (json: T, body: string, message: IncomingMessage) => void;
+export declare class UrlChecker {
+    private readonly requestOptions;
+    constructor(hostname: string, apiKey?: string);
+    static create(hostname: string, apiKeyId: string): Promise<UrlChecker>;
+    static createV2(): Promise<UrlChecker>;
+    expectStatus<T>(statusCode: number, url: string, callback: JsonCheckerFunction<T>): Promise<void>;
+    expect200<T>(url: string, ...callbacks: JsonCheckerFunction<T>[]): Promise<void>;
+    expect404(url: string): Promise<void>;
+    expect400(url: string): Promise<void>;
+    expect403WithoutApiKey(url: string, mediaType?: MediaType): Promise<void>;
+    done(): string;
+}
+export declare class ResponseChecker {
+    private readonly contentType;
+    private checkCors;
+    constructor(contentType: string);
+    static forJson(): ResponseChecker;
+    static forCSV(): ResponseChecker;
+    static forGeojson(): ResponseChecker;
+    static forJpeg(): ResponseChecker;
+    check(): CheckerFunction;
+    checkJson<T>(fn: (json: T, body: string, res: IncomingMessage) => void): CheckerFunction;
+    responseChecker(fn: (body: string, res: IncomingMessage) => void): CheckerFunction;
+}
+export declare class ContentChecker {
+    static checkJson<T>(fn: (json: T, body: string, res: IncomingMessage) => void): CheckerFunction;
+    static checkResponse(fn: (body: string, res: IncomingMessage) => void): CheckerFunction;
+}
+export declare class ContentTypeChecker {
+    static checkContentType(contentType: MediaType): (res: IncomingMessage) => void;
+}
+export declare class GeoJsonChecker {
+    static validFeatureCollection(fn?: (json: FeatureCollection) => void): CheckerFunction;
+}
+export declare class HeaderChecker {
+    static checkHeaderExists(headerName: string): CheckerFunction;
+    static checkHeaderMissing(headerName: string): CheckerFunction;
+}
+export {};

package/dist/aws/infra/documentation.d.ts

@@ -0,0 +1,56 @@
+import { Construct } from "constructs";
+import { Resource } from "aws-cdk-lib/aws-apigateway";
+/**
+ * Add description to a query parameter
+ * @param name query parameter name
+ * @param description query parameter description
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ */
+export declare function addQueryParameterDescription(name: string, description: string, resource: Resource, stack: Construct): void;
+/**
+ * Add a documentation part to a method
+ * @param methodDescription
+ * @param documentationProperties
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addDocumentation(methodDescription: string, documentationProperties: object, resource: Resource, stack: Construct): void;
+/**
+ * Adds OpenAPI tags to an API method
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addTags(methodDescription: string, tags: string[], resource: Resource, stack: Construct): void;
+/**
+ * Adds OpenAPI tags and a method summary to an API method
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ *
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param summary OpenAPI summary
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addTagsAndSummary(methodDescription: string, tags: string[], summary: string, resource: Resource, stack: Construct): void;
+export interface DocumentationProperties {
+    description?: string;
+    tags?: string[];
+    summary?: string;
+    deprecated?: boolean;
+}
+export declare class DocumentationPart {
+    readonly parameterName: string;
+    readonly type: string;
+    readonly documentationProperties: DocumentationProperties;
+    private constructor();
+    deprecated(note: string): DocumentationPart;
+    static queryParameter(parameterName: string, description: string): DocumentationPart;
+    static pathParameter(parameterName: string, description: string): DocumentationPart;
+    static method(tags: string[], name: string, summary: string): DocumentationPart;
+}

package/dist/aws/infra/import-util.d.ts

@@ -0,0 +1,21 @@
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { Stack } from "aws-cdk-lib";
+import { Construct } from "constructs";
+export declare class OldStackImports {
+    static AURORAINSTANCE_SG_IMPORT_NAME: string;
+    static RDSPROXY_SG_IMPORT_NAME: string;
+}
+/**
+ * Import VPC from other stack outputs
+ */
+export declare function importVpc(scope: Construct, environmentName: string): IVpc;
+/**
+ * Import value from other stack output.  Stack outputs are named with
+ * digitraffic-${environmentName}-${name} pattern and this function takes care of it
+ */
+export declare function importValue(environmentName: string, name: string): string;
+/**
+ * Export value as stack output.  Use same naming pattern as importValue.
+ */
+export declare function exportValue(stack: Stack, environmentName: string, name: string, value: string): void;
+export declare function outputName(environmentName: string, name: string): string;

package/dist/aws/infra/scheduler.d.ts

@@ -0,0 +1,12 @@
+import { Rule, Schedule } from "aws-cdk-lib/aws-events";
+import { Duration } from "aws-cdk-lib";
+import { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+export declare class Scheduler extends Rule {
+    constructor(stack: Construct, ruleName: string, schedule: Schedule, lambda?: AWSFunction);
+    static everyMinute(stack: Construct, ruleName: string, lambda?: AWSFunction): Scheduler;
+    static everyMinutes(stack: Construct, ruleName: string, minutes: number, lambda?: AWSFunction): Scheduler;
+    static everyHour(stack: Construct, ruleName: string, lambda?: AWSFunction): Scheduler;
+    static everyDay(stack: Construct, ruleName: string, lambda?: AWSFunction): Scheduler;
+    static every(stack: Construct, ruleName: string, duration: Duration, lambda?: AWSFunction): Scheduler;
+}

package/dist/aws/infra/security-rule.d.ts

@@ -0,0 +1,12 @@
+import { Construct } from "constructs";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { ITopic } from "aws-cdk-lib/aws-sns";
+/**
+ * Automatic rule for Security Hub.  Send notification to given topic if the following conditions apply:
+ * * There is a finding with a status of NEW
+ * * It has severity of HIGH or CRITICAL
+ * * It is in a FAILED state
+ */
+export declare class DigitrafficSecurityRule extends Rule {
+    constructor(scope: Construct, topic: ITopic);
+}

package/dist/aws/infra/sqs-integration.d.ts

@@ -0,0 +1,7 @@
+import { RequestValidator, Resource } from "aws-cdk-lib/aws-apigateway";
+import { Queue } from "aws-cdk-lib/aws-sqs";
+import { IModel } from "aws-cdk-lib/aws-apigateway/lib/model";
+import { Construct } from "constructs";
+export declare function attachQueueToApiGatewayResource(stack: Construct, queue: Queue, resource: Resource, requestValidator: RequestValidator, resourceName: string, apiKeyRequired: boolean, requestModels?: {
+    [param: string]: IModel;
+}): void;

package/dist/aws/infra/sqs-queue.d.ts

@@ -0,0 +1,16 @@
+import { Queue, QueueProps } from "aws-cdk-lib/aws-sqs";
+import { Construct } from "constructs";
+import { DigitrafficStack } from "./stack/stack";
+/**
+ * Construct for creating SQS-queues.
+ *
+ * If you don't config your own deadLetterQueue, this will create a dlq for you, also a lambda function, a s3 bucket
+ * and an alarm for the queue.  Anything that goes to the dlq will be written into the bucket and the alarm is activated.
+ */
+export declare class DigitrafficSqsQueue extends Queue {
+    constructor(scope: Construct, name: string, props: QueueProps);
+    static create(stack: DigitrafficStack, name: string, props: QueueProps): DigitrafficSqsQueue;
+}
+export declare class DigitrafficDLQueue {
+    static create(stack: DigitrafficStack, name: string): DigitrafficSqsQueue;
+}

package/dist/aws/infra/stack/lambda-configs.d.ts

@@ -0,0 +1,64 @@
+import { Architecture, Code, FunctionProps, Runtime } from "aws-cdk-lib/aws-lambda";
+import { ISecurityGroup, IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
+import { Role } from "aws-cdk-lib/aws-iam";
+import { DigitrafficStack } from "./stack";
+import { MonitoredFunctionAlarmProps } from "./monitoredfunction";
+export type LambdaEnvironment = Record<string, string>;
+export type DBLambdaEnvironment = LambdaEnvironment & {
+    SECRET_ID?: string;
+    DB_APPLICATION: string;
+};
+export interface LambdaConfiguration {
+    vpcId: string;
+    allowFromIpAddresses?: string[];
+    privateSubnetIds: string[];
+    availabilityZones: string[];
+    lambdaDbSgId: string;
+    dbProps?: DbProps;
+    defaultLambdaDurationSeconds?: number;
+    logsDestinationArn: string;
+    memorySize?: number;
+    runtime?: Runtime;
+}
+declare interface DbProps {
+    username: string;
+    password: string;
+    uri?: string;
+    ro_uri?: string;
+}
+export declare function databaseFunctionProps(stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, config?: Partial<FunctionParameters>): FunctionProps;
+export declare function lambdaFunctionProps(stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, config?: Partial<FunctionParameters>): FunctionProps;
+/**
+ * Creates a base configuration for a Lambda that uses an RDS database
+ * @param vpc "Private" Lambdas are associated with a VPC
+ * @param lambdaDbSg Security Group shared by Lambda and RDS
+ * @param props Database connection properties for the Lambda
+ * @param config Lambda configuration
+ */
+export declare function dbLambdaConfiguration(vpc: IVpc, lambdaDbSg: ISecurityGroup, props: LambdaConfiguration, config: FunctionParameters): FunctionProps;
+export declare function defaultLambdaConfiguration(config: FunctionParameters): FunctionProps;
+export interface FunctionParameters {
+    memorySize?: number;
+    timeout?: number;
+    functionName?: string;
+    code: Code;
+    handler: string;
+    readOnly?: boolean;
+    environment?: {
+        [key: string]: string;
+    };
+    reservedConcurrentExecutions?: number;
+    role?: Role;
+    vpc?: IVpc;
+    vpcSubnets?: SubnetSelection;
+    runtime?: Runtime;
+    architecture?: Architecture;
+    singleLambda?: boolean;
+}
+export type MonitoredFunctionParameters = FunctionParameters & {
+    readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly durationWarningProps?: MonitoredFunctionAlarmProps;
+    readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
+};
+export {};

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

@@ -0,0 +1,84 @@
+import { Function, FunctionProps } from "aws-cdk-lib/aws-lambda";
+import { Stack } from "aws-cdk-lib";
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+import { DigitrafficStack } from "../stack/stack";
+import { ITopic } from "aws-cdk-lib/aws-sns";
+import { LambdaEnvironment, MonitoredFunctionParameters } from "../stack/lambda-configs";
+import { TrafficType } from "../../../types/traffictype";
+/**
+ * Allows customization of CloudWatch Alarm properties
+ */
+export type MonitoredFunctionAlarmProps = {
+    /**
+     * Setting this to false will not create a CloudWatch alarm
+     */
+    readonly create: boolean;
+    readonly threshold?: number;
+    readonly evaluationPeriods?: number;
+    readonly datapointsToAlarm?: number;
+    readonly comparisonOperator?: ComparisonOperator;
+};
+export type MonitoredFunctionProps = {
+    readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly durationWarningProps?: MonitoredFunctionAlarmProps;
+    readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
+};
+/**
+ * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
+ */
+export declare class MonitoredFunction extends Function {
+    readonly givenName: string;
+    /** disable all alarms */
+    static readonly DISABLE_ALARMS: MonitoredFunctionProps;
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
+     *
+     * @param stack DigitrafficStack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param props Monitored function properties
+     */
+    static create(stack: DigitrafficStack, id: string, functionProps: FunctionProps, props?: Partial<MonitoredFunctionProps>): MonitoredFunction;
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static createV2(stack: DigitrafficStack, name: string, environment: LambdaEnvironment, functionParameters?: Partial<MonitoredFunctionParameters>): MonitoredFunction;
+    /**
+     * @param scope Stack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param alarmSnsTopic SNS topic for alarms
+     * @param warningSnsTopic SNS topic for warnings
+     * @param production Is the stack a production stack, used for determining the alarm topic
+     * @param trafficType Traffic type, used for alarm names. Set to null if Lambda is not related to any traffic type.
+     * @param props Monitored function properties
+     */
+    constructor(scope: Stack, id: string, functionProps: FunctionProps, alarmSnsTopic: ITopic, warningSnsTopic: ITopic, production: boolean, trafficType: TrafficType | null, props?: MonitoredFunctionProps);
+    private createAlarm;
+    private getAlarmActionForEnv;
+}
+export declare class MonitoredDBFunction {
+    /**
+     * Create new MonitoredDBFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     * Grant secret and create log subscription.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * If you don't need to pass any extra arguments to lambda-environment, you can leave environment out and this function will create the
+     * default Lambda Environment with SECRET_ID and DB_APPLICATION.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static create(stack: DigitrafficStack, name: string, environment?: LambdaEnvironment, functionParameters?: Partial<MonitoredFunctionParameters>): MonitoredFunction;
+}

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

@@ -0,0 +1,41 @@
+import { RestApi, RestApiProps, JsonSchema, Resource } from "aws-cdk-lib/aws-apigateway";
+import { PolicyDocument } from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+import { DigitrafficStack } from "./stack";
+import { ModelWithReference } from "../../types/model-with-reference";
+import { DocumentationPart } from "../documentation";
+export declare class DigitrafficRestApi extends RestApi {
+    readonly apiKeyIds: string[];
+    readonly enableDocumentation: boolean;
+    constructor(stack: DigitrafficStack, apiId: string, apiName: string, allowFromIpAddresses?: string[] | undefined, config?: Partial<RestApiProps>);
+    hostname(): string;
+    createUsagePlan(apiKeyId: string, apiKeyName: string): string;
+    createUsagePlanV2(apiName: string, apiKey?: string): string;
+    addJsonModel(modelName: string, schema: JsonSchema): ModelWithReference;
+    addCSVModel(modelName: string): ModelWithReference;
+    private getModelWithReference;
+    private addDocumentationPart;
+    documentResource(resource: Resource, ...documentationPart: DocumentationPart[]): void;
+}
+/**
+ * Due to AWS API design API Gateway will always return 403 'Missing Authentication Token' for requests
+ * with a non-existent endpoint. This function translates this response to a 404.
+ * Requests with an invalid or missing API key are not affected (still return 403 'Forbidden').
+ * @param restApi RestApi
+ * @param stack Construct
+ */
+export declare function add404Support(restApi: RestApi, stack: Construct): void;
+export declare function add401Support(restApi: RestApi, stack: Construct): void;
+/**
+ * Due to AWS API design API Gateway will always return 403 'Missing Authentication Token' for requests
+ * with a non-existent endpoint. This function converts this response to a custom one.
+ * Requests with an invalid or missing API key are not affected (still return 403 'Forbidden').
+ * @param returnCode
+ * @param message
+ * @param restApi RestApi
+ * @param stack Construct
+ */
+export declare function setReturnCodeForMissingAuthenticationToken(returnCode: number, message: string, restApi: RestApi, stack: Construct): void;
+export declare function createRestApi(stack: Construct, apiId: string, apiName: string, allowFromIpAddresses?: string[] | undefined): RestApi;
+export declare function createDefaultPolicyDocument(): PolicyDocument;
+export declare function createIpRestrictionPolicyDocument(allowFromIpAddresses: string[]): PolicyDocument;

package/dist/aws/infra/stack/stack-checking-aspect.d.ts

@@ -0,0 +1,21 @@
+import { IAspect } from "aws-cdk-lib";
+import { DigitrafficStack } from "./stack";
+import { IConstruct } from "constructs";
+export declare class StackCheckingAspect implements IAspect {
+    private readonly stackShortName?;
+    private readonly whitelistedResources?;
+    constructor(stackShortName?: string, whitelistedResources?: string[]);
+    static create(stack: DigitrafficStack): StackCheckingAspect;
+    visit(node: IConstruct): void;
+    private isWhitelisted;
+    private addAnnotation;
+    private checkStack;
+    private checkFunction;
+    private checkTags;
+    private checkBucket;
+    private static isValidPath;
+    private static isValidQueryString;
+    private checkResourceCasing;
+    private checkQueueEncryption;
+    private checkLogGroupRetention;
+}