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

package/dist/aws/infra/stacks/db-dns-stack.js

@@ -0,0 +1,60 @@
+import { Duration, RemovalPolicy, Stack } from "aws-cdk-lib";
+import { PrivateHostedZone, RecordSet, RecordTarget, RecordType, } from "aws-cdk-lib/aws-route53";
+import { importVpc } from "../import-util.js";
+import { getParameterValue } from "../stack/parameters.js";
+const DEFAULT_RECORD_TTL = Duration.seconds(30);
+/**
+ * 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 class DbDnsStack extends Stack {
+    constructor(scope, id, isc) {
+        super(scope, id, {
+            env: isc.env,
+        });
+        this.createDnsRecords(isc);
+    }
+    createDnsRecords(isc) {
+        const vpc = importVpc(this, isc.environmentName);
+        const zone = new PrivateHostedZone(this, "DNSHostedZone", {
+            zoneName: `${isc.environmentName}.local`,
+            vpc,
+        });
+        zone.applyRemovalPolicy(RemovalPolicy.RETAIN);
+        const clusterReaderEndpoint = getParameterValue(this, "cluster.reader");
+        const clusterWriterEndpoint = getParameterValue(this, "cluster.writer");
+        const proxyReaderEndpoint = getParameterValue(this, "proxy.reader");
+        const proxyWriterEndpoint = getParameterValue(this, "proxy.writer");
+        new RecordSet(this, "ReaderRecord", {
+            recordType: RecordType.CNAME,
+            recordName: `db-ro.${isc.environmentName}.local`,
+            target: RecordTarget.fromValues(clusterReaderEndpoint),
+            ttl: DEFAULT_RECORD_TTL,
+            zone,
+        });
+        new RecordSet(this, "WriterRecord", {
+            recordType: RecordType.CNAME,
+            recordName: `db.${isc.environmentName}.local`,
+            target: RecordTarget.fromValues(clusterWriterEndpoint),
+            ttl: DEFAULT_RECORD_TTL,
+            zone,
+        });
+        new RecordSet(this, "ProxyReaderRecord", {
+            recordType: RecordType.CNAME,
+            recordName: `proxy-ro.${isc.environmentName}.local`,
+            target: RecordTarget.fromValues(proxyReaderEndpoint),
+            ttl: DEFAULT_RECORD_TTL,
+            zone,
+        });
+        new RecordSet(this, "ProxyWriterRecord", {
+            recordType: RecordType.CNAME,
+            recordName: `proxy.${isc.environmentName}.local`,
+            target: RecordTarget.fromValues(proxyWriterEndpoint),
+            ttl: DEFAULT_RECORD_TTL,
+            zone,
+        });
+    }
+}
+//# sourceMappingURL=db-dns-stack.js.map

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

@@ -0,0 +1,24 @@
+import type { IVpc } from "aws-cdk-lib/aws-ec2";
+import { CfnDBProxyEndpoint, DatabaseProxy } from "aws-cdk-lib/aws-rds";
+import type { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { Stack } from "aws-cdk-lib/core";
+import type { Construct } from "constructs/lib/construct.js";
+import type { InfraStackConfiguration } from "./intra-stack-configuration.js";
+export interface ProxyConfiguration {
+    readonly secretArn: string;
+    readonly name?: string;
+    readonly securityGroupId: string;
+    readonly clusterIdentifier: string;
+}
+/**
+ * A stack that creates a Database proxy.
+ */
+export declare class DbProxyStack extends Stack {
+    readonly isc: InfraStackConfiguration;
+    static PROXY_READER_EXPORT_NAME: string;
+    static PROXY_WRITER_EXPORT_NAME: string;
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration, configuration: ProxyConfiguration);
+    setOutputs(proxy: DatabaseProxy): void;
+    createProxy(vpc: IVpc, secret: ISecret, configuration: ProxyConfiguration): DatabaseProxy;
+    createProxyEndpoints(vpc: IVpc, proxy: DatabaseProxy, securityGroupId: string): CfnDBProxyEndpoint;
+}

package/dist/aws/infra/stacks/db-proxy-stack.js

@@ -0,0 +1,74 @@
+import { SecurityGroup } from "aws-cdk-lib/aws-ec2";
+import { CfnDBProxyEndpoint, DatabaseCluster, DatabaseClusterEngine, DatabaseProxy, ProxyTarget, } from "aws-cdk-lib/aws-rds";
+import { Secret } from "aws-cdk-lib/aws-secretsmanager";
+import { Duration, Stack } from "aws-cdk-lib/core";
+import { exportValue, importVpc } from "../import-util.js";
+import { createParameter } from "../stack/parameters.js";
+import { DbStack } from "./db-stack.js";
+/**
+ * A stack that creates a Database proxy.
+ */
+export class DbProxyStack extends Stack {
+    isc;
+    static PROXY_READER_EXPORT_NAME = "db-reader-endpoint";
+    static PROXY_WRITER_EXPORT_NAME = "db-writer-endpoint";
+    constructor(scope, id, isc, configuration) {
+        super(scope, id, {
+            env: isc.env,
+        });
+        this.isc = isc;
+        if (configuration.clusterIdentifier === "") {
+            throw new Error("Empty cluster identifier!");
+        }
+        const vpc = importVpc(this, isc.environmentName);
+        const secret = Secret.fromSecretAttributes(this, "proxy-secret", {
+            secretCompleteArn: configuration.secretArn,
+        });
+        const proxy = this.createProxy(vpc, secret, configuration);
+        const readerEndpoint = this.createProxyEndpoints(vpc, proxy, configuration.securityGroupId);
+        createParameter(this, "proxy.reader", readerEndpoint.attrEndpoint);
+        createParameter(this, "proxy.writer", proxy.endpoint);
+        this.setOutputs(proxy);
+    }
+    setOutputs(proxy) {
+        // if only one instance, then there is no reader-endpoint
+        exportValue(this, this.isc.environmentName, DbProxyStack.PROXY_READER_EXPORT_NAME, proxy.endpoint);
+        exportValue(this, this.isc.environmentName, DbProxyStack.PROXY_WRITER_EXPORT_NAME, proxy.endpoint);
+    }
+    createProxy(vpc, secret, configuration) {
+        const proxyId = `${this.isc.environmentName}-proxy`;
+        const securityGroup = SecurityGroup.fromSecurityGroupId(this, "securitygroup", configuration.securityGroupId);
+        const cluster = DatabaseCluster.fromDatabaseClusterAttributes(this, "db-cluster", {
+            clusterIdentifier: configuration.clusterIdentifier,
+            engine: DatabaseClusterEngine.AURORA_POSTGRESQL,
+            port: DbStack.CLUSTER_PORT,
+        });
+        // CDK tries to allow connections between proxy and cluster
+        // this does not work on cluster references
+        cluster.connections.allowDefaultPortFrom = () => {
+            /* nothing */
+        };
+        return new DatabaseProxy(this, proxyId, {
+            dbProxyName: configuration.name ?? "AuroraProxy",
+            securityGroups: [securityGroup],
+            proxyTarget: ProxyTarget.fromCluster(cluster),
+            idleClientTimeout: Duration.seconds(1800),
+            maxConnectionsPercent: 50,
+            maxIdleConnectionsPercent: 25,
+            borrowTimeout: Duration.seconds(120),
+            requireTLS: false,
+            secrets: [secret],
+            vpc: vpc,
+        });
+    }
+    createProxyEndpoints(vpc, proxy, securityGroupId) {
+        return new CfnDBProxyEndpoint(this, "ReaderEndpoint", {
+            dbProxyEndpointName: "ReaderEndpoint",
+            dbProxyName: proxy.dbProxyName,
+            vpcSubnetIds: vpc.privateSubnets.map((sub) => sub.subnetId),
+            vpcSecurityGroupIds: [securityGroupId],
+            targetRole: "READ_ONLY",
+        });
+    }
+}
+//# sourceMappingURL=db-proxy-stack.js.map

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

@@ -0,0 +1,65 @@
+import type { InstanceType, ISecurityGroup, IVpc } from "aws-cdk-lib/aws-ec2";
+import { Key } from "aws-cdk-lib/aws-kms";
+import type { AuroraPostgresEngineVersion, DatabaseClusterProps, IParameterGroup } from "aws-cdk-lib/aws-rds";
+import { DatabaseCluster } from "aws-cdk-lib/aws-rds";
+import { Stack } from "aws-cdk-lib/core";
+import type { Construct } from "constructs/lib/construct.js";
+import type { InfraStackConfiguration } from "./intra-stack-configuration.js";
+export interface DbConfiguration {
+    readonly cluster?: ClusterConfiguration;
+    readonly clusterImport?: ClusterImportConfiguration;
+    readonly storageEncrypted?: boolean;
+    readonly customParameterGroups: AuroraPostgresEngineVersion[];
+    readonly workmem?: number;
+    /** superuser username and password are fetched from this secret, using keys
+     * db.superuser and db.superuser.password
+     */
+    readonly secretArn: string;
+    /** If this is not specified, import default vpc */
+    readonly vpc?: IVpc;
+}
+export interface ClusterDbInstanceConfiguration {
+    readonly instanceType: InstanceType;
+    readonly isFromLegacyInstanceProps?: boolean;
+}
+export interface ClusterConfiguration {
+    readonly securityGroupId: string;
+    readonly snapshotIdentifier?: string;
+    readonly dbVersion: AuroraPostgresEngineVersion;
+    readonly writer: ClusterDbInstanceConfiguration;
+    readonly readers: ClusterDbInstanceConfiguration[];
+}
+export interface ClusterImportConfiguration {
+    readonly clusterReadEndpoint: string;
+    readonly clusterWriteEndpoint: string;
+}
+/**
+ * Parse cluster identifier from cluster writer endpoint.
+ * i.e. <i>stackenv-stackenvxxx-xxx.cluster-xxx.region.rds.amazonaws.com</i>
+ * -> <i>stackenv-stackenvxxx-xxx</i>
+ * @param clusterImport ClusterImportConfiguration to resolve cluster identifier
+ * @param fallbackValue If parse fails return fallback value. If not given will throw error.
+ * @throws Error If not cluster is found and no fallbackValue is given.
+ */
+export declare function parseClusterIdentifier(clusterImport?: ClusterImportConfiguration, fallbackValue?: string): string;
+/**
+ * Stack that creates DatabaseCluster.
+ *
+ * Please not, that created Cluster has RETAIL removalPolicy, so if you want to delete the stack,
+ * you must first deploy without parameter group, then delete stack and manually delete cluster.
+ *
+ * You should deploy once with cluster and then without.  This way you can create the cluster with this
+ * stack, but cluster is not part of the stack after that.
+ */
+export declare class DbStack extends Stack {
+    static CLUSTER_PORT: number;
+    static CLUSTER_IDENTIFIER_EXPORT_NAME: string;
+    static CLUSTER_READ_ENDPOINT_EXPORT_NAME: string;
+    static CLUSTER_WRITE_ENDPOINT_EXPORT_NAME: string;
+    clusterIdentifier: string;
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration, configuration: DbConfiguration);
+    createParameterGroups(customVersions: AuroraPostgresEngineVersion[], workmem: number): IParameterGroup[];
+    createClusterParameters(secretArn: string, clusterConfiguration: ClusterConfiguration, instanceName: string, vpc: IVpc, securityGroup: ISecurityGroup, parameterGroup: IParameterGroup, storageEncrypted: boolean | undefined, rdsKey: Key | undefined): DatabaseClusterProps;
+    createRDSKey(instanceName: string, environmentName: string): Key;
+    createAuroraCluster(isc: InfraStackConfiguration, configuration: DbConfiguration, clusterConfiguration: ClusterConfiguration, parameterGroups: IParameterGroup[], instanceName: string, rdsKey: Key | undefined): DatabaseCluster;
+}

package/dist/aws/infra/stacks/db-stack.js

@@ -0,0 +1,189 @@
+import { SecurityGroup, SubnetType } from "aws-cdk-lib/aws-ec2";
+import { Key } from "aws-cdk-lib/aws-kms";
+import { CfnDBInstance, ClusterInstance, Credentials, DatabaseCluster, DatabaseClusterEngine, DatabaseClusterFromSnapshot, InstanceUpdateBehaviour, ParameterGroup, } from "aws-cdk-lib/aws-rds";
+import { Secret } from "aws-cdk-lib/aws-secretsmanager";
+import { Duration, RemovalPolicy, Stack } from "aws-cdk-lib/core";
+import { exportValue, importVpc } from "../import-util.js";
+import { createParameter } from "../stack/parameters.js";
+/**
+ * Parse cluster identifier from cluster writer endpoint.
+ * i.e. <i>stackenv-stackenvxxx-xxx.cluster-xxx.region.rds.amazonaws.com</i>
+ * -> <i>stackenv-stackenvxxx-xxx</i>
+ * @param clusterImport ClusterImportConfiguration to resolve cluster identifier
+ * @param fallbackValue If parse fails return fallback value. If not given will throw error.
+ * @throws Error If not cluster is found and no fallbackValue is given.
+ */
+export function parseClusterIdentifier(clusterImport, fallbackValue) {
+    if (clusterImport?.clusterWriteEndpoint.includes(".cluster") &&
+        clusterImport.clusterWriteEndpoint.split(".cluster")[0]) {
+        // @ts-expect-error this is checked above
+        return clusterImport.clusterWriteEndpoint.split(".cluster")[0];
+    }
+    if (fallbackValue) {
+        return fallbackValue;
+    }
+    throw new Error([
+        `Could not resolve 'clusterIdentifier' from 'configuration.clusterImport': ${clusterImport?.clusterWriteEndpoint}.,
+     'configuration.clusterImport.clusterWriteEndpoint' didn't contain '.cluster'`,
+    ].join(" "));
+}
+/**
+ * Stack that creates DatabaseCluster.
+ *
+ * Please not, that created Cluster has RETAIL removalPolicy, so if you want to delete the stack,
+ * you must first deploy without parameter group, then delete stack and manually delete cluster.
+ *
+ * You should deploy once with cluster and then without.  This way you can create the cluster with this
+ * stack, but cluster is not part of the stack after that.
+ */
+export class DbStack extends Stack {
+    static CLUSTER_PORT = 5432;
+    static CLUSTER_IDENTIFIER_EXPORT_NAME = "db-cluster";
+    static CLUSTER_READ_ENDPOINT_EXPORT_NAME = "db-cluster-reader-endpoint";
+    static CLUSTER_WRITE_ENDPOINT_EXPORT_NAME = "db-cluster-writer-endpoint";
+    clusterIdentifier = "";
+    constructor(scope, id, isc, configuration) {
+        super(scope, id, {
+            env: isc.env,
+        });
+        const parameterGroups = this.createParameterGroups(configuration.customParameterGroups, configuration.workmem ?? 524288);
+        if ((configuration.cluster && configuration.clusterImport) ||
+            (!configuration.cluster && !configuration.clusterImport)) {
+            throw new Error("Configure either cluster or clusterImport");
+        }
+        const instanceName = `${isc.environmentName}-db`;
+        const rdsKey = configuration?.storageEncrypted
+            ? this.createRDSKey(instanceName, isc.environmentName)
+            : undefined;
+        // create cluster if this is wanted, should do it only once
+        if (configuration.cluster) {
+            const cluster = this.createAuroraCluster(isc, configuration, configuration.cluster, parameterGroups, instanceName, rdsKey);
+            exportValue(this, isc.environmentName, DbStack.CLUSTER_IDENTIFIER_EXPORT_NAME, cluster.clusterIdentifier);
+            exportValue(this, isc.environmentName, DbStack.CLUSTER_WRITE_ENDPOINT_EXPORT_NAME, cluster.clusterEndpoint.hostname);
+            exportValue(this, isc.environmentName, DbStack.CLUSTER_READ_ENDPOINT_EXPORT_NAME, cluster.clusterReadEndpoint.hostname);
+            createParameter(this, "cluster.reader", cluster.clusterReadEndpoint.hostname);
+            createParameter(this, "cluster.writer", cluster.clusterEndpoint.hostname);
+            createParameter(this, "cluster.identifier", cluster.clusterIdentifier);
+            this.clusterIdentifier = cluster.clusterIdentifier;
+        }
+        if (configuration.clusterImport) {
+            this.clusterIdentifier = parseClusterIdentifier(configuration.clusterImport);
+            createParameter(this, "cluster.reader", configuration.clusterImport.clusterReadEndpoint);
+            createParameter(this, "cluster.writer", configuration.clusterImport.clusterWriteEndpoint);
+            createParameter(this, "cluster.identifier", this.clusterIdentifier);
+        }
+    }
+    createParameterGroups(customVersions, workmem) {
+        return customVersions.map((version) => {
+            const pg = new ParameterGroup(this, `parameter-group-${version.auroraPostgresMajorVersion}`, {
+                engine: DatabaseClusterEngine.auroraPostgres({
+                    version,
+                }),
+                parameters: {
+                    "pg_stat_statements.track": "ALL",
+                    random_page_cost: "1",
+                    work_mem: workmem.toString(),
+                },
+            });
+            // create both cluster parameter group and instance parameter group
+            pg.bindToCluster({});
+            pg.bindToInstance({});
+            return pg;
+        });
+    }
+    createClusterParameters(secretArn, clusterConfiguration, instanceName, vpc, securityGroup, parameterGroup, storageEncrypted, rdsKey) {
+        const secret = Secret.fromSecretCompleteArn(this, "DBSecret", secretArn);
+        const defaultDbInstanceProps = {
+            autoMinorVersionUpgrade: true,
+            allowMajorVersionUpgrade: false,
+            enablePerformanceInsights: true,
+            parameterGroup: parameterGroup,
+        };
+        const writer = ClusterInstance.provisioned("WriterInstance", {
+            ...{
+                instanceType: clusterConfiguration.writer.instanceType,
+                isFromLegacyInstanceProps: clusterConfiguration.writer.isFromLegacyInstanceProps,
+            },
+            ...defaultDbInstanceProps,
+        });
+        const readers = clusterConfiguration.readers.map((reader, index) => ClusterInstance.provisioned(`ReaderInstance${index}`, {
+            ...{
+                instanceType: reader.instanceType,
+                isFromLegacyInstanceProps: reader.isFromLegacyInstanceProps,
+            },
+            ...defaultDbInstanceProps,
+        }));
+        return {
+            engine: DatabaseClusterEngine.auroraPostgres({
+                version: clusterConfiguration.dbVersion,
+            }),
+            writer,
+            readers,
+            vpcSubnets: {
+                subnetType: SubnetType.PRIVATE_WITH_EGRESS,
+            },
+            securityGroups: [securityGroup],
+            vpc,
+            instanceUpdateBehaviour: InstanceUpdateBehaviour.ROLLING,
+            instanceIdentifierBase: `${instanceName}-`,
+            cloudwatchLogsExports: ["postgresql"],
+            backup: {
+                retention: Duration.days(35),
+                preferredWindow: "01:00-02:00",
+            },
+            preferredMaintenanceWindow: "mon:03:00-mon:04:00",
+            deletionProtection: true,
+            removalPolicy: RemovalPolicy.RETAIN,
+            port: DbStack.CLUSTER_PORT,
+            credentials: Credentials.fromPassword(secret.secretValueFromJson("db.superuser").unsafeUnwrap(), secret.secretValueFromJson("db.superuser.password")),
+            parameterGroup,
+            monitoringInterval: Duration.seconds(30),
+            storageEncrypted: storageEncrypted ?? true,
+            ...(rdsKey ? { storageEncryptionKey: rdsKey } : {}),
+        };
+    }
+    createRDSKey(instanceName, environmentName) {
+        return new Key(this, "RDSKey", {
+            alias: `${environmentName}/db`,
+            enableKeyRotation: true,
+            description: `KMS key for RDS cluster ${instanceName}`,
+            removalPolicy: RemovalPolicy.RETAIN,
+            pendingWindow: Duration.days(30),
+        });
+    }
+    createAuroraCluster(isc, configuration, clusterConfiguration, parameterGroups, instanceName, rdsKey) {
+        const securityGroup = SecurityGroup.fromSecurityGroupId(this, "securitygroup", clusterConfiguration.securityGroupId);
+        const vpc = configuration.vpc
+            ? configuration.vpc
+            : importVpc(this, isc.environmentName);
+        if (parameterGroups[0] === undefined) {
+            throw Error("ParameterGroups should not be empty");
+        }
+        const parameters = this.createClusterParameters(configuration.secretArn, clusterConfiguration, instanceName, vpc, securityGroup, parameterGroups[0], configuration.storageEncrypted, rdsKey);
+        let cluster;
+        if (clusterConfiguration.snapshotIdentifier) {
+            cluster = new DatabaseClusterFromSnapshot(this, instanceName, {
+                ...parameters,
+                ...{
+                    snapshotIdentifier: clusterConfiguration.snapshotIdentifier,
+                },
+            });
+        }
+        else {
+            cluster = new DatabaseCluster(this, instanceName, parameters);
+        }
+        // this workaround should prevent stack failing on version upgrade
+        // https://github.com/aws/aws-cdk/issues/21758
+        // https://github.com/aws/aws-cdk/pull/22185
+        // Maybe this could be removed completely as we don't update db with the CDK?
+        const cfnInstances = cluster.node.children.filter((child) => child instanceof CfnDBInstance);
+        // if (cfnInstances.length === 0) {
+        //     throw new Error("Couldn't pull CfnDBInstances from the L1 constructs!");
+        // }
+        cfnInstances.forEach((cfnInstance) => {
+            delete cfnInstance.engineVersion;
+        });
+        return cluster;
+    }
+}
+//# sourceMappingURL=db-stack.js.map

package/dist/aws/infra/stacks/intra-stack-configuration.d.ts

@@ -0,0 +1,5 @@
+import type { Environment } from "aws-cdk-lib/core";
+export interface InfraStackConfiguration {
+    readonly env: Environment;
+    readonly environmentName: string;
+}

package/dist/aws/infra/stacks/intra-stack-configuration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=intra-stack-configuration.js.map

package/dist/aws/infra/stacks/network-stack.d.ts

@@ -0,0 +1,14 @@
+import type { IVpc } from "aws-cdk-lib/aws-ec2";
+import { Vpc } from "aws-cdk-lib/aws-ec2";
+import { Stack } from "aws-cdk-lib/core";
+import type { Construct } from "constructs/lib/construct.js";
+import type { InfraStackConfiguration } from "./intra-stack-configuration.js";
+export interface NetworkConfiguration {
+    readonly vpcName: string;
+    readonly cidr: string;
+}
+export declare class NetworkStack extends Stack {
+    readonly vpc: IVpc;
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration, configuration: NetworkConfiguration);
+    createVpc(configuration: NetworkConfiguration): Vpc;
+}

package/dist/aws/infra/stacks/network-stack.js

@@ -0,0 +1,45 @@
+import { IpAddresses, SubnetType, Vpc } from "aws-cdk-lib/aws-ec2";
+import { Stack } from "aws-cdk-lib/core";
+import { exportValue } from "../import-util.js";
+export class NetworkStack extends Stack {
+    vpc;
+    constructor(scope, id, isc, configuration) {
+        super(scope, id, {
+            env: isc.env,
+        });
+        this.vpc = this.createVpc(configuration);
+        if (this.vpc.publicSubnets[0] === undefined ||
+            this.vpc.publicSubnets[1] === undefined ||
+            this.vpc.privateSubnets[0] === undefined ||
+            this.vpc.privateSubnets[1] === undefined) {
+            throw Error("Subnets are not set correctly");
+        }
+        exportValue(this, isc.environmentName, "VPCID", this.vpc.vpcId);
+        exportValue(this, isc.environmentName, "digitrafficpublicASubnet", this.vpc.publicSubnets[0].subnetId);
+        exportValue(this, isc.environmentName, "digitrafficpublicBSubnet", this.vpc.publicSubnets[1].subnetId);
+        exportValue(this, isc.environmentName, "digitrafficprivateASubnet", this.vpc.privateSubnets[0].subnetId);
+        exportValue(this, isc.environmentName, "digitrafficprivateBSubnet", this.vpc.privateSubnets[1].subnetId);
+    }
+    createVpc(configuration) {
+        return new Vpc(this, "DigitrafficVPC", {
+            vpcName: configuration.vpcName,
+            availabilityZones: Stack.of(this).availabilityZones.sort().slice(0, 2), // take two first azs
+            enableDnsHostnames: true,
+            enableDnsSupport: true,
+            ipAddresses: IpAddresses.cidr(configuration.cidr),
+            subnetConfiguration: [
+                {
+                    name: "public",
+                    cidrMask: 24,
+                    subnetType: SubnetType.PUBLIC,
+                },
+                {
+                    name: "private",
+                    cidrMask: 24,
+                    subnetType: SubnetType.PRIVATE_WITH_EGRESS,
+                },
+            ],
+        });
+    }
+}
+//# sourceMappingURL=network-stack.js.map

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

@@ -0,0 +1,16 @@
+import type { 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'
+ * @param value Optional value for the API key
+ */
+export declare function createDefaultUsagePlan(api: RestApi, apiName: string, value?: string): IApiKey;

package/dist/aws/infra/usage-plans.js

@@ -0,0 +1,38 @@
+/**
+ * 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 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;
+}
+/**
+ * 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'
+ * @param value Optional value for the API key
+ */
+export function createDefaultUsagePlan(api, apiName, value) {
+    const apiKeyName = `${apiName} API Key`;
+    const usagePlanName = `${apiName} API Usage Plan`;
+    const apiKey = api.addApiKey(apiKeyName, { apiKeyName: apiKeyName, value });
+    const plan = api.addUsagePlan(usagePlanName, {
+        name: usagePlanName,
+    });
+    plan.addApiStage({
+        stage: api.deploymentStage,
+    });
+    plan.addApiKey(apiKey);
+    return apiKey;
+}
+//# sourceMappingURL=usage-plans.js.map

package/dist/aws/runtime/apikey.d.ts

@@ -0,0 +1,2 @@
+import type { GetApiKeyCommandOutput } from "@aws-sdk/client-api-gateway";
+export declare function getApiKeyFromAPIGateway(keyId: string): Promise<GetApiKeyCommandOutput>;

package/dist/aws/runtime/apikey.js

@@ -0,0 +1,13 @@
+import { APIGatewayClient, GetApiKeyCommand, } from "@aws-sdk/client-api-gateway";
+import { FetchHttpHandler } from "@smithy/fetch-http-handler";
+export async function getApiKeyFromAPIGateway(keyId) {
+    const client = new APIGatewayClient({
+        requestHandler: new FetchHttpHandler(),
+    });
+    const command = new GetApiKeyCommand({
+        apiKey: keyId,
+        includeValue: true,
+    });
+    return await client.send(command);
+}
+//# sourceMappingURL=apikey.js.map

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

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

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

@@ -0,0 +1,25 @@
+import { getDeprecatedDefaultLambdaResponse, RESPONSE_DEFAULT_LAMBDA, } from "../infra/api/response.js";
+import { MediaType } from "../types/mediatypes.js";
+// biome-ignore lint/complexity/noStaticOnlyClass: FIXME
+export class DigitrafficIntegrationResponse {
+    static ok(mediaType, deprecation = false, sunset) {
+        return DigitrafficIntegrationResponse.create("200", mediaType, deprecation, sunset);
+    }
+    static badRequest(mediaType) {
+        return DigitrafficIntegrationResponse.create("400", mediaType ?? MediaType.TEXT_PLAIN);
+    }
+    static notImplemented(mediaType) {
+        return DigitrafficIntegrationResponse.create("501", mediaType ?? MediaType.TEXT_PLAIN);
+    }
+    static create(statusCode, mediaType, deprecation = false, sunset) {
+        return {
+            statusCode,
+            responseTemplates: {
+                [mediaType]: deprecation
+                    ? getDeprecatedDefaultLambdaResponse(sunset)
+                    : RESPONSE_DEFAULT_LAMBDA,
+            },
+        };
+    }
+}
+//# sourceMappingURL=digitraffic-integration-response.js.map

package/dist/aws/runtime/dt-logger-default.d.ts

@@ -0,0 +1,9 @@
+import { DtLogger } from "./dt-logger.js";
+/**
+ * You can use this for method name definition to match DtLogger LoggableType.method parameter.
+ */
+export type { LoggerMethodType } from "./dt-logger.js";
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+export declare const logger: DtLogger;

package/dist/aws/runtime/dt-logger-default.js

@@ -0,0 +1,6 @@
+import { DtLogger } from "./dt-logger.js";
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+export const logger = new DtLogger();
+//# sourceMappingURL=dt-logger-default.js.map