@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

package/dist/aws/infra/stack/rest-api.js

@@ -0,0 +1,235 @@
+import { CfnDocumentationPart, Cors, EndpointType, GatewayResponse, MethodLoggingLevel, ResponseType, RestApi, } from "aws-cdk-lib/aws-apigateway";
+import { AnyPrincipal, Effect, PolicyDocument, PolicyStatement, } from "aws-cdk-lib/aws-iam";
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import { set } from "es-toolkit/compat";
+import { getModelReference } from "../../../utils/api-model.js";
+import { MediaType } from "../../types/mediatypes.js";
+import { createDefaultUsagePlan, createUsagePlan } from "../usage-plans.js";
+export const PUBLIC_REST_API_CORS_CONFIG = {
+    defaultCorsPreflightOptions: {
+        allowOrigins: Cors.ALL_ORIGINS,
+        allowHeaders: [
+            "Content-Type",
+            "X-Amz-Date",
+            "Authorization",
+            "X-Api-Key",
+            "X-Amz-Security-Token",
+            "Digitraffic-User",
+        ],
+        allowMethods: ["OPTIONS", "GET", "HEAD"],
+    },
+};
+export class DigitrafficRestApi extends RestApi {
+    apiKeyIds;
+    enableDocumentation;
+    _stack;
+    constructor(stack, apiId, apiName, allowFromIpAddresses, config) {
+        const policyDocument = allowFromIpAddresses === null || allowFromIpAddresses === undefined
+            ? createDefaultPolicyDocument()
+            : createIpRestrictionPolicyDocument(allowFromIpAddresses);
+        // override default config with given extra config
+        const apiConfig = {
+            ...{
+                deployOptions: {
+                    loggingLevel: MethodLoggingLevel.ERROR,
+                },
+                restApiName: apiName,
+                endpointTypes: [EndpointType.REGIONAL],
+                policy: policyDocument,
+            },
+            ...config,
+        };
+        super(stack, apiId, apiConfig);
+        this._stack = stack;
+        this.apiKeyIds = [];
+        this.enableDocumentation =
+            stack.configuration.stackFeatures?.enableDocumentation ?? true;
+        add404Support(this, stack);
+    }
+    hostname() {
+        return `${this.restApiId}.execute-api.${this.stack.region}.amazonaws.com`;
+    }
+    exportEndpoint(params) {
+        const firstKey = this.apiKeyIds[0];
+        var apiKeyId = params?.apiKeyId;
+        if (!apiKeyId) {
+            if (this.apiKeyIds.length > 1) {
+                throw new Error("Multiple apikeys, configure which to export");
+            }
+            if (!firstKey) {
+                throw new Error("No apikeys to export");
+            }
+            apiKeyId = firstKey;
+        }
+        const exportName = params?.exportName ?? this._stack.configuration.shortName;
+        const sp1 = new StringParameter(this._stack, `export.endpoint.${exportName}`, {
+            parameterName: `/digitraffic/${exportName}/endpointUrl`,
+            stringValue: this.url,
+        });
+        const sp2 = new StringParameter(this._stack, `export.apiKeyId.${exportName}`, {
+            parameterName: `/digitraffic/${exportName}/apiKeyId`,
+            stringValue: apiKeyId,
+        });
+        return [sp1, sp2];
+    }
+    /**
+     * @param apiKeyId
+     * @param apiKeyName
+     * @deprecated Uses deprecated createUsagePlan that creates randomized API key names, use createUsagePlanV2 instead
+     */
+    createUsagePlan(apiKeyId, apiKeyName) {
+        const newKeyId = createUsagePlan(this, apiKeyId, apiKeyName).keyId;
+        this.apiKeyIds.push(newKeyId);
+        return newKeyId;
+    }
+    createUsagePlanV2(apiName, apiKey) {
+        const newKeyId = createDefaultUsagePlan(this, apiName, apiKey).keyId;
+        this.apiKeyIds.push(newKeyId);
+        return newKeyId;
+    }
+    addJsonModel(modelName, schema) {
+        return this.getModelWithReference(this.addModel(modelName, {
+            contentType: MediaType.APPLICATION_JSON,
+            modelName,
+            schema,
+        }));
+    }
+    addCSVModel(modelName) {
+        return this.getModelWithReference(this.addModel(modelName, {
+            contentType: MediaType.TEXT_CSV,
+            modelName,
+            schema: {},
+        }));
+    }
+    getModelWithReference(model) {
+        return set(model, "modelReference", getModelReference(model.modelId, this.restApiId));
+    }
+    addDocumentationPart(resource, parameterName, resourceName, type, properties) {
+        const location = {
+            type,
+            path: resource.path,
+            name: type !== "METHOD" ? parameterName : undefined,
+        };
+        new CfnDocumentationPart(this.stack, resourceName, {
+            restApiId: resource.api.restApiId,
+            location,
+            properties: JSON.stringify(properties),
+        });
+    }
+    documentResource(resource, ...documentationPart) {
+        if (this.enableDocumentation) {
+            documentationPart.forEach((dp) => {
+                this.addDocumentationPart(resource, dp.parameterName, `${resource.path}.${dp.parameterName}.Documentation`, dp.type, dp.documentationProperties);
+            });
+        }
+        else {
+            console.info("Skipping documentation for %s", resource.path);
+        }
+    }
+    addResourceWithCorsOptionsSubTree(resource, pathPart, config) {
+        const mergedConfig = {
+            ...PUBLIC_REST_API_CORS_CONFIG,
+            ...config,
+        };
+        return resource.addResource(pathPart, mergedConfig);
+    }
+    /**
+     * Add support for HTTP OPTIONS to an API GW resource,
+     * this is required for preflight CORS requests made by browsers.
+     * @param apiResource
+     */
+    addCorsOptions(apiResource) {
+        apiResource.addCorsPreflight(PUBLIC_REST_API_CORS_CONFIG.defaultCorsPreflightOptions);
+    }
+}
+/**
+ * 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 function add404Support(restApi, stack) {
+    new GatewayResponse(stack, `MissingAuthenticationTokenResponse-${restApi.restApiName}`, {
+        restApi,
+        type: ResponseType.MISSING_AUTHENTICATION_TOKEN,
+        statusCode: "404",
+        templates: {
+            [MediaType.APPLICATION_JSON]: '{"message": "Not Found"}',
+        },
+    });
+}
+export function add401Support(restApi, stack) {
+    new GatewayResponse(stack, `AuthenticationFailedResponse-${restApi.restApiName}`, {
+        restApi,
+        type: ResponseType.UNAUTHORIZED,
+        statusCode: "401",
+        responseHeaders: {
+            "WWW-Authenticate": "'Basic'",
+        },
+    });
+}
+/**
+ * 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 function setReturnCodeForMissingAuthenticationToken(returnCode, message, restApi, stack) {
+    new GatewayResponse(stack, `MissingAuthenticationTokenResponse-${restApi.restApiName}`, {
+        restApi,
+        type: ResponseType.MISSING_AUTHENTICATION_TOKEN,
+        statusCode: `${returnCode}`,
+        templates: {
+            [MediaType.APPLICATION_JSON]: `{"message": ${message}}`,
+        },
+    });
+}
+export function createRestApi(stack, apiId, apiName, allowFromIpAddresses) {
+    const policyDocument = allowFromIpAddresses === null || allowFromIpAddresses === undefined
+        ? createDefaultPolicyDocument()
+        : createIpRestrictionPolicyDocument(allowFromIpAddresses);
+    const restApi = new RestApi(stack, apiId, {
+        deployOptions: {
+            loggingLevel: MethodLoggingLevel.ERROR,
+        },
+        restApiName: apiName,
+        endpointTypes: [EndpointType.REGIONAL],
+        policy: policyDocument,
+    });
+    add404Support(restApi, stack);
+    return restApi;
+}
+export function createDefaultPolicyDocument() {
+    return new PolicyDocument({
+        statements: [
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: ["execute-api:Invoke"],
+                resources: ["*"],
+                principals: [new AnyPrincipal()],
+            }),
+        ],
+    });
+}
+export function createIpRestrictionPolicyDocument(allowFromIpAddresses) {
+    return new PolicyDocument({
+        statements: [
+            new PolicyStatement({
+                effect: Effect.ALLOW,
+                conditions: {
+                    IpAddress: {
+                        "aws:SourceIp": allowFromIpAddresses,
+                    },
+                },
+                actions: ["execute-api:Invoke"],
+                resources: ["*"],
+                principals: [new AnyPrincipal()],
+            }),
+        ],
+    });
+}
+//# sourceMappingURL=rest-api.js.map

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

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

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

@@ -0,0 +1,183 @@
+import { Annotations, Stack } from "aws-cdk-lib";
+import { CfnMethod, CfnResource } from "aws-cdk-lib/aws-apigateway";
+import { CfnFunction, Runtime } from "aws-cdk-lib/aws-lambda";
+import { LogRetention } from "aws-cdk-lib/aws-logs";
+import { CfnBucket } from "aws-cdk-lib/aws-s3";
+import { CfnQueue } from "aws-cdk-lib/aws-sqs";
+import { kebabCase } from "change-case";
+import { snakeCase } from "es-toolkit";
+import { DigitrafficStack, SOLUTION_KEY } from "./stack.js";
+const MAX_CONCURRENCY_LIMIT = 100;
+const ALLOWED_RUNTIMES = [
+    Runtime.NODEJS_24_X.name,
+    Runtime.NODEJS_22_X.name,
+    Runtime.PYTHON_3_12.name,
+    Runtime.PYTHON_3_13.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 = {}));
+export class StackCheckingAspect {
+    stackShortName;
+    whitelistedResources;
+    constructor(stackShortName, whitelistedResources) {
+        this.stackShortName = stackShortName;
+        this.whitelistedResources = whitelistedResources;
+    }
+    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.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) {
+            Annotations.of(node).addError(annotationMessage);
+        }
+        else if ((!isError && !isWhiteListed) || (isError && isWhiteListed)) {
+            Annotations.of(node).addWarning(annotationMessage);
+        }
+    }
+    isDigitrafficStack(node) {
+        return node instanceof DigitrafficStack;
+    }
+    checkStack(node) {
+        // Fix Invalid 'instanceof' check: 'nodeToCheck' has type that is not related to 'DigitrafficStack'
+        if (this.isDigitrafficStack(node)) {
+            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 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 !== undefined &&
+                !ALLOWED_RUNTIMES.includes(node.runtime)) {
+                this.addAnnotation(node, ResourceType.functionRuntime, `Function has wrong runtime ${node.runtime}!`);
+            }
+            if (this.stackShortName &&
+                node.functionName &&
+                !node.functionName.startsWith(this.stackShortName)) {
+                this.addAnnotation(node, ResourceType.functionName, `Function name does not begin with ${this.stackShortName}`);
+            }
+        }
+    }
+    checkTags(node) {
+        if (node instanceof Stack) {
+            if (!node.tags.tagValues()[SOLUTION_KEY]) {
+                this.addAnnotation(node, ResourceType.tagSolution, "Solution tag is missing");
+            }
+        }
+    }
+    checkBucket(node) {
+        if (node instanceof CfnBucket) {
+            const c = node.publicAccessBlockConfiguration;
+            if (c &&
+                (!c.blockPublicAcls ||
+                    !c.blockPublicPolicy ||
+                    !c.ignorePublicAcls ||
+                    !c.restrictPublicBuckets)) {
+                this.addAnnotation(node, ResourceType.bucketPublicity, "Check bucket publicity");
+            }
+        }
+    }
+    static isValidPath(path) {
+        if (!path) {
+            return false;
+        }
+        // if path includes . or { check only the trailing part of path
+        if (path.includes(".")) {
+            return StackCheckingAspect.isValidPath(path.split(".")[0]);
+        }
+        if (path.includes("{")) {
+            return StackCheckingAspect.isValidPath(path.split("{")[0]);
+        }
+        return kebabCase(path) === path;
+    }
+    static isValidQueryString(name) {
+        return snakeCase(name) === name;
+    }
+    checkResourceCasing(node) {
+        if (node instanceof CfnResource) {
+            if (!StackCheckingAspect.isValidPath(node.pathPart)) {
+                this.addAnnotation(node, ResourceType.resourcePath, "Path part should be in kebab-case", false);
+            }
+        }
+        else if (node instanceof CfnMethod) {
+            const integration = node.integration;
+            if (integration?.requestParameters) {
+                Object.keys(integration.requestParameters).forEach((key) => {
+                    const split = key.split(".");
+                    const type = split[2];
+                    const name = split[3];
+                    if (name === undefined) {
+                        throw Error("Name should not be undefined");
+                    }
+                    if (type === "querystring" &&
+                        !StackCheckingAspect.isValidQueryString(name)) {
+                        this.addAnnotation(node, name, "Querystring should be in snake_case");
+                    }
+                });
+            }
+        }
+    }
+    checkQueueEncryption(node) {
+        if (node instanceof CfnQueue) {
+            if (!node.kmsMasterKeyId) {
+                this.addAnnotation(node, ResourceType.queueEncryption, "Queue must have encryption enabled");
+            }
+        }
+    }
+    checkLogGroupRetention(node) {
+        if (node instanceof 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");
+            }
+        }
+    }
+}
+//# sourceMappingURL=stack-checking-aspect.js.map

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

@@ -0,0 +1,56 @@
+import type { StackProps } from "aws-cdk-lib";
+import { Stack } from "aws-cdk-lib";
+import type { ISecurityGroup, IVpc } from "aws-cdk-lib/aws-ec2";
+import type { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import type { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import type { ITopic } from "aws-cdk-lib/aws-sns";
+import type { Construct } from "constructs";
+import type { TrafficType } from "../../../types/traffictype.js";
+import type { DBLambdaEnvironment } from "./lambda-configs.js";
+export declare const SOLUTION_KEY = "Solution";
+export declare const SSM_KEY_WARNING_TOPIC = "/digitraffic/monitoring/warning-topic";
+export declare const SSM_KEY_ALARM_TOPIC = "/digitraffic/monitoring/alarm-topic";
+export interface StackConfiguration {
+    readonly shortName: string;
+    readonly secretId?: string;
+    readonly alarmTopicArn: string;
+    readonly warningTopicArn: string;
+    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 stackFeatures?: {
+        readonly enableCanaries?: boolean;
+        readonly enableDocumentation?: boolean;
+    };
+    readonly whitelistedResources?: string[];
+}
+export interface DigitrafficStackLike {
+    readonly configuration: StackConfiguration;
+    readonly vpc?: IVpc;
+    readonly lambdaDbSg?: ISecurityGroup;
+    readonly alarmTopic: ITopic;
+    readonly warningTopic: ITopic;
+    createLambdaEnvironment(): DBLambdaEnvironment;
+    createDefaultLambdaEnvironment(dbApplication: string): DBLambdaEnvironment;
+    getSecret(): ISecret;
+    grantSecret(...lambdas: AWSFunction[]): void;
+}
+export declare class DigitrafficStack extends Stack implements DigitrafficStackLike {
+    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;
+    getSecret(): ISecret;
+    grantSecret(...lambdas: AWSFunction[]): void;
+}

package/dist/aws/infra/stack/stack.js

@@ -0,0 +1,71 @@
+import { Aspects, Stack } from "aws-cdk-lib";
+import { SecurityGroup, Vpc } from "aws-cdk-lib/aws-ec2";
+import { Secret } from "aws-cdk-lib/aws-secretsmanager";
+import { Topic } from "aws-cdk-lib/aws-sns";
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import { StackCheckingAspect } from "./stack-checking-aspect.js";
+const SSM_ROOT = "/digitraffic";
+export const SOLUTION_KEY = "Solution";
+const MONITORING_ROOT = "/monitoring";
+export const SSM_KEY_WARNING_TOPIC = `${SSM_ROOT}${MONITORING_ROOT}/warning-topic`;
+export const SSM_KEY_ALARM_TOPIC = `${SSM_ROOT}${MONITORING_ROOT}/alarm-topic`;
+export class DigitrafficStack extends Stack {
+    vpc;
+    lambdaDbSg;
+    alarmTopic;
+    warningTopic;
+    secret;
+    configuration;
+    constructor(scope, id, configuration) {
+        super(scope, id, configuration.stackProps);
+        this.configuration = configuration;
+        if (configuration.secretId) {
+            this.secret = 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 = 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 = SecurityGroup.fromSecurityGroupId(this, "LambdaDbSG", configuration.lambdaDbSgId);
+        }
+        this.alarmTopic = Topic.fromTopicArn(this, "AlarmTopic", StringParameter.fromStringParameterName(this, "AlarmTopicParam", SSM_KEY_ALARM_TOPIC).stringValue);
+        this.warningTopic = Topic.fromTopicArn(this, "WarningTopic", StringParameter.fromStringParameterName(this, "WarningTopicParam", SSM_KEY_WARNING_TOPIC).stringValue);
+        this.addAspects();
+    }
+    addAspects() {
+        Aspects.of(this).add(new StackCheckingAspect(this.configuration.shortName, this.configuration.whitelistedResources));
+    }
+    createLambdaEnvironment() {
+        return this.createDefaultLambdaEnvironment(this.configuration.shortName);
+    }
+    createDefaultLambdaEnvironment(dbApplication) {
+        return this.configuration.secretId
+            ? {
+                SECRET_ID: this.configuration.secretId,
+                DB_APPLICATION: dbApplication,
+            }
+            : {
+                DB_APPLICATION: dbApplication,
+            };
+    }
+    getSecret() {
+        if (this.secret === undefined) {
+            throw new Error("Secret is undefined");
+        }
+        return this.secret;
+    }
+    grantSecret(...lambdas) {
+        const secret = this.getSecret();
+        lambdas.forEach((l) => {
+            secret.grantRead(l);
+        });
+    }
+}
+//# sourceMappingURL=stack.js.map

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

@@ -0,0 +1,17 @@
+import type { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import { CfnSubscriptionFilter } from "aws-cdk-lib/aws-logs";
+import type { Construct } from "constructs";
+import type { MonitoredFunction } from "./monitoredfunction.js";
+import type { DigitrafficStack } from "./stack.js";
+/**
+ * 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: AWSFunction, lambdaName: string, logDestinationArn: string | undefined, stack: Construct): CfnSubscriptionFilter | undefined;
+export declare class DigitrafficLogSubscriptions {
+    constructor(stack: DigitrafficStack, ...lambdas: MonitoredFunction[]);
+}

package/dist/aws/infra/stack/subscription.js

@@ -0,0 +1,37 @@
+import { CfnSubscriptionFilter } from "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
+ */
+export function createSubscription(lambda, lambdaName, logDestinationArn, stack) {
+    if (logDestinationArn === undefined || logDestinationArn === null) {
+        return undefined;
+    }
+    const filter = new CfnSubscriptionFilter(stack, `${lambdaName}LogsSubscription`, {
+        logGroupName: lambda.logGroup.logGroupName,
+        filterPattern: "",
+        destinationArn: logDestinationArn,
+    });
+    filter.node.addDependency(lambda);
+    return filter;
+}
+export class DigitrafficLogSubscriptions {
+    constructor(stack, ...lambdas) {
+        const destinationArn = stack.configuration.logsDestinationArn;
+        if (destinationArn !== undefined) {
+            lambdas.forEach((lambda) => {
+                const filter = new CfnSubscriptionFilter(stack, `${lambda.givenName}LogsSubscription`, {
+                    logGroupName: lambda.logGroup.logGroupName,
+                    filterPattern: "",
+                    destinationArn,
+                });
+                filter.node.addDependency(lambda);
+            });
+        }
+    }
+}
+//# sourceMappingURL=subscription.js.map

package/dist/aws/infra/stacks/db-dns-stack.d.ts

@@ -0,0 +1,13 @@
+import { Stack } from "aws-cdk-lib";
+import type { Construct } from "constructs";
+import type { InfraStackConfiguration } from "./intra-stack-configuration.js";
+/**
+ * Creates a dns local zone and creates records for cluster endpoints and proxy endpoints.
+ *
+ * Please note, that created PrivateHostedZone has RETAIN removalPolicy, so if you want to delete this stack,
+ * you must remove the zone by hand after.
+ */
+export declare class DbDnsStack extends Stack {
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration);
+    createDnsRecords(isc: InfraStackConfiguration): void;
+}