@digitraffic/common 2024.1.10-1 → 2024.1.23-1

package/dist/aws/infra/{sqs-queue.js → sqs-queue.mjs}

@@ -1,30 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DigitrafficDLQueue = exports.DigitrafficSqsQueue = void 0;
-const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const aws_s3_1 = require("aws-cdk-lib/aws-s3");
-const aws_iam_1 = require("aws-cdk-lib/aws-iam");
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_logs_1 = require("aws-cdk-lib/aws-logs");
-const aws_lambda_event_sources_1 = require("aws-cdk-lib/aws-lambda-event-sources");
-const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
-const aws_cloudwatch_actions_1 = require("aws-cdk-lib/aws-cloudwatch-actions");
-const lib_storage_1 = require("@aws-sdk/lib-storage");
-const monitoredfunction_1 = require("./stack/monitoredfunction");
+import { Queue, QueueEncryption } from "aws-cdk-lib/aws-sqs";
+import { Duration } from "aws-cdk-lib";
+import { BlockPublicAccess, Bucket } from "aws-cdk-lib/aws-s3";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { InlineCode, Runtime } from "aws-cdk-lib/aws-lambda";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
+import { ComparisonOperator, TreatMissingData } from "aws-cdk-lib/aws-cloudwatch";
+import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
+import { S3 } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { MonitoredFunction } from "./stack/monitoredfunction.mjs";
 /**
  * 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.
  */
-class DigitrafficSqsQueue extends aws_sqs_1.Queue {
+export class DigitrafficSqsQueue extends Queue {
     static create(stack, name, props) {
         const queueName = `${stack.configuration.shortName}-${name}-Queue`;
         const queueProps = {
             ...props,
             ...{
-                encryption: aws_sqs_1.QueueEncryption.KMS_MANAGED,
+                encryption: QueueEncryption.KMS_MANAGED,
                 queueName,
                 deadLetterQueue: props.deadLetterQueue ?? {
                     maxReceiveCount: 2,
@@ -35,60 +33,58 @@ class DigitrafficSqsQueue extends aws_sqs_1.Queue {
         return new DigitrafficSqsQueue(stack, queueName, queueProps);
     }
 }
-exports.DigitrafficSqsQueue = DigitrafficSqsQueue;
-class DigitrafficDLQueue {
+export class DigitrafficDLQueue {
     static create(stack, name) {
         const dlqName = `${stack.configuration.shortName}-${name}-DLQ`;
         const dlq = new DigitrafficSqsQueue(stack, dlqName, {
             queueName: dlqName,
-            visibilityTimeout: aws_cdk_lib_1.Duration.seconds(60),
-            encryption: aws_sqs_1.QueueEncryption.KMS_MANAGED,
+            visibilityTimeout: Duration.seconds(60),
+            encryption: QueueEncryption.KMS_MANAGED,
         });
-        const dlqBucket = new aws_s3_1.Bucket(stack, `${dlqName}-Bucket`, {
-            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+        const dlqBucket = new Bucket(stack, `${dlqName}-Bucket`, {
+            blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
         });
         const dlqFunctionName = `${dlqName}-Function`;
-        const lambda = monitoredfunction_1.MonitoredFunction.create(stack, dlqFunctionName, {
-            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
-            logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        const lambda = MonitoredFunction.create(stack, dlqFunctionName, {
+            runtime: Runtime.NODEJS_20_X,
+            logRetention: RetentionDays.ONE_YEAR,
             functionName: dlqFunctionName,
             code: getDlqCode(dlqBucket.bucketName),
-            timeout: aws_cdk_lib_1.Duration.seconds(10),
+            timeout: Duration.seconds(10),
             handler: "index.handler",
             memorySize: 128,
             reservedConcurrentExecutions: 1,
         });
-        const statement = new aws_iam_1.PolicyStatement();
+        const statement = new PolicyStatement();
         statement.addActions("s3:PutObject");
         statement.addActions("s3:PutObjectAcl");
         statement.addResources(dlqBucket.bucketArn + "/*");
         lambda.addToRolePolicy(statement);
-        lambda.addEventSource(new aws_lambda_event_sources_1.SqsEventSource(dlq));
+        lambda.addEventSource(new SqsEventSource(dlq));
         addDLQAlarm(stack, dlqName, dlq);
         return dlq;
     }
 }
-exports.DigitrafficDLQueue = DigitrafficDLQueue;
 function addDLQAlarm(stack, dlqName, dlq) {
     const alarmName = `${dlqName}-Alarm`;
     dlq.metricNumberOfMessagesReceived({
-        period: aws_cdk_lib_1.Duration.minutes(5),
+        period: Duration.minutes(5),
     })
         .createAlarm(stack, alarmName, {
         alarmName,
         threshold: 0,
         evaluationPeriods: 1,
-        treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
-        comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+        treatMissingData: TreatMissingData.NOT_BREACHING,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,
     })
-        .addAlarmAction(new aws_cloudwatch_actions_1.SnsAction(stack.warningTopic));
+        .addAlarmAction(new SnsAction(stack.warningTopic));
 }
 function getDlqCode(Bucket) {
     const functionBody = DLQ_LAMBDA_CODE.replace("__bucketName__", Bucket)
         .replace("__upload__", uploadToS3.toString())
         .replace("__doUpload__", doUpload.toString())
         .replace("__handler__", createHandler().toString().substring(23)); // remove function handler() from signature
-    return new aws_lambda_1.InlineCode(functionBody);
+    return new InlineCode(functionBody);
 }
 async function uploadToS3(s3, Bucket, Body, Key) {
     try {
@@ -108,7 +104,7 @@ async function uploadToS3(s3, Bucket, Body, Key) {
 }
 async function doUpload(s3, Bucket, Body, Key) {
     try {
-        const upload = new lib_storage_1.Upload({
+        const upload = new Upload({
             client: s3,
             params: { Bucket, Key, Body },
         });
@@ -122,12 +118,8 @@ async function doUpload(s3, Bucket, Body, Key) {
 const bucketName = "";
 function createHandler() {
     return async function handler(event) {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment
-        const AWS = require("aws-sdk");
         const millis = new Date().getTime();
-        await Promise.all(event.Records.map((e, idx) => uploadToS3(
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        new AWS.S3(), bucketName, e.body, `dlq-${millis}-${idx}.json`)));
+        await Promise.all(event.Records.map((e, idx) => uploadToS3(new S3(), bucketName, e.body, `dlq-${millis}-${idx}.json`)));
     };
 }
 const DLQ_LAMBDA_CODE = `
@@ -140,4 +132,4 @@ __doUpload__
 
 exports.handler = async (event) => __handler__
 `;
-//# sourceMappingURL=sqs-queue.js.map
+//# sourceMappingURL=sqs-queue.mjs.map

package/dist/aws/infra/stack/{lambda-configs.d.ts → lambda-configs.d.mts}

@@ -1,8 +1,8 @@
 import { Architecture, Code, FunctionProps, Runtime } from "aws-cdk-lib/aws-lambda";
 import { IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
 import { Role } from "aws-cdk-lib/aws-iam";
-import { DigitrafficStack } from "./stack";
-import { MonitoredFunctionAlarmProps } from "./monitoredfunction";
+import { DigitrafficStack } from "./stack.mjs";
+import { MonitoredFunctionAlarmProps } from "./monitoredfunction.mjs";
 export type LambdaEnvironment = Record<string, string>;
 export type DBLambdaEnvironment = LambdaEnvironment & {
     SECRET_ID?: string;

package/dist/aws/infra/stack/{lambda-configs.js → lambda-configs.mjs}

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultLambdaConfiguration = exports.lambdaFunctionProps = exports.databaseFunctionProps = void 0;
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const aws_logs_1 = require("aws-cdk-lib/aws-logs");
-function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
+import { Architecture, AssetCode, Runtime, } from "aws-cdk-lib/aws-lambda";
+import { Duration } from "aws-cdk-lib";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+export function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
     const vpcSubnets = stack.vpc
         ? {
             subnets: stack.vpc.privateSubnets,
@@ -19,41 +16,39 @@ function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName,
         },
     };
 }
-exports.databaseFunctionProps = databaseFunctionProps;
-function lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
+export function lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
     return {
-        runtime: config?.runtime ?? aws_lambda_1.Runtime.NODEJS_20_X,
-        architecture: config?.architecture ?? aws_lambda_1.Architecture.ARM_64,
+        runtime: config?.runtime ?? Runtime.NODEJS_20_X,
+        architecture: config?.architecture ?? Architecture.ARM_64,
         memorySize: config?.memorySize ?? 128,
         functionName: lambdaName,
         role: config?.role,
-        timeout: aws_cdk_lib_1.Duration.seconds(config?.timeout ?? 60),
-        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        timeout: Duration.seconds(config?.timeout ?? 60),
+        logRetention: RetentionDays.ONE_YEAR,
         reservedConcurrentExecutions: config?.reservedConcurrentExecutions ?? 2,
         code: getAssetCode(simpleLambdaName, config?.singleLambda ?? false),
         handler: `${simpleLambdaName}.handler`,
         environment,
     };
 }
-exports.lambdaFunctionProps = lambdaFunctionProps;
 function getAssetCode(simpleLambdaName, isSingleLambda) {
     const lambdaPath = isSingleLambda
         ? `dist/lambda/`
         : `dist/lambda/${simpleLambdaName}`;
-    return new aws_lambda_1.AssetCode(lambdaPath);
+    return new AssetCode(lambdaPath);
 }
-function defaultLambdaConfiguration(config) {
+export function defaultLambdaConfiguration(config) {
     const props = {
-        runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+        runtime: Runtime.NODEJS_20_X,
         memorySize: config.memorySize ?? 128,
         functionName: config.functionName,
         handler: config.handler,
         environment: config.environment ?? {},
-        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        logRetention: RetentionDays.ONE_YEAR,
         reservedConcurrentExecutions: config.reservedConcurrentExecutions,
         code: config.code,
         role: config.role,
-        timeout: aws_cdk_lib_1.Duration.seconds(config.timeout ?? 10),
+        timeout: Duration.seconds(config.timeout ?? 10),
     };
     if (config.vpc) {
         return {
@@ -68,5 +63,4 @@ function defaultLambdaConfiguration(config) {
     }
     return props;
 }
-exports.defaultLambdaConfiguration = defaultLambdaConfiguration;
-//# sourceMappingURL=lambda-configs.js.map
+//# sourceMappingURL=lambda-configs.mjs.map

package/dist/aws/infra/stack/{monitoredfunction.d.ts → monitoredfunction.d.mts}

@@ -1,10 +1,10 @@
 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 { DigitrafficStack } from "./stack.mjs";
 import { ITopic } from "aws-cdk-lib/aws-sns";
-import { LambdaEnvironment, MonitoredFunctionParameters } from "../stack/lambda-configs";
-import { TrafficType } from "../../../types/traffictype";
+import { LambdaEnvironment, MonitoredFunctionParameters } from "./lambda-configs.mjs";
+import { TrafficType } from "../../../types/traffictype.mjs";
 /**
  * Allows customization of CloudWatch Alarm properties
  */

package/dist/aws/infra/stack/{monitoredfunction.js → monitoredfunction.mjs}

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonitoredDBFunction = exports.MonitoredFunction = void 0;
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_cloudwatch_actions_1 = require("aws-cdk-lib/aws-cloudwatch-actions");
-const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
-const lambda_configs_1 = require("../stack/lambda-configs");
-const subscription_1 = require("../stack/subscription");
-const lodash_1 = __importDefault(require("lodash"));
+import { Function } from "aws-cdk-lib/aws-lambda";
+import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+import { databaseFunctionProps, } from "./lambda-configs.mjs";
+import { DigitrafficLogSubscriptions } from "./subscription.mjs";
+import _ from "lodash";
 /**
  * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
  */
-class MonitoredFunction extends aws_lambda_1.Function {
+export class MonitoredFunction extends Function {
     /**
      * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
      *
@@ -43,12 +37,12 @@ class MonitoredFunction extends aws_lambda_1.Function {
      */
     static createV2(stack, name, environment, functionParameters) {
         const functionName = functionParameters?.functionName ??
-            `${stack.configuration.shortName}-${lodash_1.default.chain(name)
+            `${stack.configuration.shortName}-${_.chain(name)
                 .camelCase()
                 .startCase()
                 .replace(/\s/g, "")
                 .value()}`;
-        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
+        const functionProps = databaseFunctionProps(stack, environment, functionName, name, functionParameters);
         return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
     }
     /**
@@ -67,25 +61,25 @@ class MonitoredFunction extends aws_lambda_1.Function {
             throw new Error("Function name not provided");
         }
         this.givenName = functionProps.functionName;
-        const alarmSnsAction = new aws_cloudwatch_actions_1.SnsAction(alarmSnsTopic);
-        const warningSnsAction = new aws_cloudwatch_actions_1.SnsAction(warningSnsTopic);
+        const alarmSnsAction = new SnsAction(alarmSnsTopic);
+        const warningSnsAction = new SnsAction(warningSnsTopic);
         if (props?.durationAlarmProps?.create !== false) {
             if (!functionProps.timeout) {
                 throw new Error("Timeout needs to be explicitly set");
             }
-            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration", "Duration alarm", `Duration has exceeded ${functionProps.timeout.toSeconds()} seconds`, trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), functionProps.timeout.toMilliseconds(), 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationAlarmProps);
+            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration", "Duration alarm", `Duration has exceeded ${functionProps.timeout.toSeconds()} seconds`, trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), functionProps.timeout.toMilliseconds(), 1, 1, ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationAlarmProps);
         }
         if (props?.durationWarningProps?.create !== false) {
             if (!functionProps.timeout) {
                 throw new Error("Timeout needs to be explicitly set");
             }
-            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration-Warning", "Duration warning", `Duration is 85 % of max ${functionProps.timeout.toSeconds()} seconds`, trafficType, warningSnsAction, functionProps.timeout.toMilliseconds() * 0.85, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationWarningProps);
+            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration-Warning", "Duration warning", `Duration is 85 % of max ${functionProps.timeout.toSeconds()} seconds`, trafficType, warningSnsAction, functionProps.timeout.toMilliseconds() * 0.85, 1, 1, ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationWarningProps);
         }
         if (props?.errorAlarmProps?.create !== false) {
-            this.createAlarm(scope, this.metricErrors(), "Errors", "Errors alarm", "Invocations did not succeed", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 1, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.errorAlarmProps);
+            this.createAlarm(scope, this.metricErrors(), "Errors", "Errors alarm", "Invocations did not succeed", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 1, 1, 1, ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.errorAlarmProps);
         }
         if (props?.throttleAlarmProps?.create !== false) {
-            this.createAlarm(scope, this.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 0, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
+            this.createAlarm(scope, this.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 0, 1, 1, ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
         }
     }
     createAlarm(stack, metric, alarmId, alarmName, alarmDescription, trafficType, alarmSnsAction, threshold, evaluationPeriods, datapointsToAlarm, comparisonOperator, alarmProps) {
@@ -104,7 +98,6 @@ class MonitoredFunction extends aws_lambda_1.Function {
         return production ? alarmAction : warningAction;
     }
 }
-exports.MonitoredFunction = MonitoredFunction;
 /** disable all alarms */
 MonitoredFunction.DISABLE_ALARMS = {
     durationAlarmProps: {
@@ -120,7 +113,7 @@ MonitoredFunction.DISABLE_ALARMS = {
         create: false,
     },
 };
-class MonitoredDBFunction {
+export class MonitoredDBFunction {
     /**
      * Create new MonitoredDBFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
      * Grant secret and create log subscription.
@@ -137,20 +130,19 @@ class MonitoredDBFunction {
      */
     static create(stack, name, environment, functionParameters) {
         const functionName = functionParameters?.functionName ??
-            `${stack.configuration.shortName}-${lodash_1.default.chain(name)
+            `${stack.configuration.shortName}-${_.chain(name)
                 .camelCase()
                 .startCase()
                 .replace(/\s/g, "")
                 .value()}`;
         const env = environment ? environment : stack.createLambdaEnvironment();
-        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, env, functionName, name, functionParameters);
+        const functionProps = databaseFunctionProps(stack, env, functionName, name, functionParameters);
         const mf = MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
         stack.grantSecret(mf);
         if (stack.configuration.logsDestinationArn) {
-            new subscription_1.DigitrafficLogSubscriptions(stack, mf);
+            new DigitrafficLogSubscriptions(stack, mf);
         }
         return mf;
     }
 }
-exports.MonitoredDBFunction = MonitoredDBFunction;
-//# sourceMappingURL=monitoredfunction.js.map
+//# sourceMappingURL=monitoredfunction.mjs.map

package/dist/aws/infra/stack/{parameters.d.ts → parameters.d.mts}

@@ -1,5 +1,5 @@
 import { StringParameter } from "aws-cdk-lib/aws-ssm";
-import { Construct } from "constructs/lib/construct";
+import { type Construct } from "constructs";
 declare const PARAMETERS: {
     readonly "topic.alarm": {
         readonly parameterName: "/digitraffic/monitoring/alarm-topic";

package/dist/aws/infra/stack/{parameters.js → parameters.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParameter = exports.getParameterValue = void 0;
-const aws_ssm_1 = require("aws-cdk-lib/aws-ssm");
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
 const SSM_ROOT = "/digitraffic";
 const MONITORING_ROOT = "/monitoring";
 const DB_ROOT = "/db";
@@ -38,18 +35,16 @@ const PARAMETERS = {
         description: "Proxy writer endpoint",
     },
 };
-function getParameterValue(scope, parameterType) {
+export function getParameterValue(scope, parameterType) {
     const parameterName = PARAMETERS[parameterType].parameterName;
-    return aws_ssm_1.StringParameter.valueForStringParameter(scope, parameterName);
+    return StringParameter.valueForStringParameter(scope, parameterName);
 }
-exports.getParameterValue = getParameterValue;
-function createParameter(scope, parameterType, stringValue) {
+export function createParameter(scope, parameterType, stringValue) {
     const { id, parameterName, description } = PARAMETERS[parameterType];
-    return new aws_ssm_1.StringParameter(scope, id, {
+    return new StringParameter(scope, id, {
         parameterName,
         description,
         stringValue,
     });
 }
-exports.createParameter = createParameter;
-//# sourceMappingURL=parameters.js.map
+//# sourceMappingURL=parameters.mjs.map

package/dist/aws/infra/stack/{rest_apis.d.ts → rest_apis.d.mts}

@@ -1,9 +1,9 @@
 import { IResource, JsonSchema, Resource, RestApi, RestApiProps } from "aws-cdk-lib/aws-apigateway";
 import { PolicyDocument } from "aws-cdk-lib/aws-iam";
 import { Construct } from "constructs";
-import { ModelWithReference } from "../../types/model-with-reference";
-import { DocumentationPart } from "../documentation";
-import { DigitrafficStack } from "./stack";
+import { ModelWithReference } from "../../types/model-with-reference.mjs";
+import { DocumentationPart } from "../documentation.mjs";
+import { DigitrafficStack } from "./stack.mjs";
 export declare class DigitrafficRestApi extends RestApi {
     readonly apiKeyIds: string[];
     readonly enableDocumentation: boolean;

package/dist/aws/infra/stack/{rest_apis.js → rest_apis.mjs}

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIpRestrictionPolicyDocument = exports.createDefaultPolicyDocument = exports.createRestApi = exports.setReturnCodeForMissingAuthenticationToken = exports.add401Support = exports.add404Support = exports.DigitrafficRestApi = void 0;
-const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
-const aws_iam_1 = require("aws-cdk-lib/aws-iam");
-const api_model_1 = require("../../../utils/api-model");
-const mediatypes_1 = require("../../types/mediatypes");
-const usage_plans_1 = require("../usage-plans");
-const lodash_1 = __importDefault(require("lodash"));
-class DigitrafficRestApi extends aws_apigateway_1.RestApi {
+import { CfnDocumentationPart, EndpointType, GatewayResponse, MethodLoggingLevel, MockIntegration, ResponseType, RestApi, } from "aws-cdk-lib/aws-apigateway";
+import { AnyPrincipal, Effect, PolicyDocument, PolicyStatement, } from "aws-cdk-lib/aws-iam";
+import { getModelReference } from "../../../utils/api-model.mjs";
+import { MediaType } from "../../types/mediatypes.mjs";
+import { createDefaultUsagePlan, createUsagePlan } from "../usage-plans.mjs";
+import _ from "lodash";
+export class DigitrafficRestApi extends RestApi {
     constructor(stack, apiId, apiName, allowFromIpAddresses, config) {
         const policyDocument = allowFromIpAddresses == null
             ? createDefaultPolicyDocument()
@@ -19,10 +13,10 @@ class DigitrafficRestApi extends aws_apigateway_1.RestApi {
         const apiConfig = {
             ...{
                 deployOptions: {
-                    loggingLevel: aws_apigateway_1.MethodLoggingLevel.ERROR,
+                    loggingLevel: MethodLoggingLevel.ERROR,
                 },
                 restApiName: apiName,
-                endpointTypes: [aws_apigateway_1.EndpointType.REGIONAL],
+                endpointTypes: [EndpointType.REGIONAL],
                 policy: policyDocument,
             },
             ...config,
@@ -37,31 +31,31 @@ class DigitrafficRestApi extends aws_apigateway_1.RestApi {
         return `${this.restApiId}.execute-api.${this.stack.region}.amazonaws.com`;
     }
     createUsagePlan(apiKeyId, apiKeyName) {
-        const newKeyId = (0, usage_plans_1.createUsagePlan)(this, apiKeyId, apiKeyName).keyId;
+        const newKeyId = createUsagePlan(this, apiKeyId, apiKeyName).keyId;
         this.apiKeyIds.push(newKeyId);
         return newKeyId;
     }
     createUsagePlanV2(apiName, apiKey) {
-        const newKeyId = (0, usage_plans_1.createDefaultUsagePlan)(this, apiName, apiKey).keyId;
+        const newKeyId = createDefaultUsagePlan(this, apiName, apiKey).keyId;
         this.apiKeyIds.push(newKeyId);
         return newKeyId;
     }
     addJsonModel(modelName, schema) {
         return this.getModelWithReference(this.addModel(modelName, {
-            contentType: mediatypes_1.MediaType.APPLICATION_JSON,
+            contentType: MediaType.APPLICATION_JSON,
             modelName,
             schema,
         }));
     }
     addCSVModel(modelName) {
         return this.getModelWithReference(this.addModel(modelName, {
-            contentType: mediatypes_1.MediaType.TEXT_CSV,
+            contentType: MediaType.TEXT_CSV,
             modelName,
             schema: {},
         }));
     }
     getModelWithReference(model) {
-        return lodash_1.default.set(model, "modelReference", (0, api_model_1.getModelReference)(model.modelId, this.restApiId));
+        return _.set(model, "modelReference", getModelReference(model.modelId, this.restApiId));
     }
     addDocumentationPart(resource, parameterName, resourceName, type, properties) {
         const location = {
@@ -69,7 +63,7 @@ class DigitrafficRestApi extends aws_apigateway_1.RestApi {
             path: resource.path,
             name: type !== "METHOD" ? parameterName : undefined,
         };
-        new aws_apigateway_1.CfnDocumentationPart(this.stack, resourceName, {
+        new CfnDocumentationPart(this.stack, resourceName, {
             restApiId: resource.api.restApiId,
             location,
             properties: JSON.stringify(properties),
@@ -89,7 +83,7 @@ class DigitrafficRestApi extends aws_apigateway_1.RestApi {
      * @param apiResource
      */
     addCorsOptions(apiResource) {
-        apiResource.addMethod("OPTIONS", new aws_apigateway_1.MockIntegration({
+        apiResource.addMethod("OPTIONS", new MockIntegration({
             integrationResponses: [
                 {
                     statusCode: "200",
@@ -117,7 +111,6 @@ class DigitrafficRestApi extends aws_apigateway_1.RestApi {
         });
     }
 }
-exports.DigitrafficRestApi = DigitrafficRestApi;
 /**
  * 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.
@@ -125,28 +118,26 @@ exports.DigitrafficRestApi = DigitrafficRestApi;
  * @param restApi RestApi
  * @param stack Construct
  */
-function add404Support(restApi, stack) {
-    new aws_apigateway_1.GatewayResponse(stack, `MissingAuthenticationTokenResponse-${restApi.restApiName}`, {
+export function add404Support(restApi, stack) {
+    new GatewayResponse(stack, `MissingAuthenticationTokenResponse-${restApi.restApiName}`, {
         restApi,
-        type: aws_apigateway_1.ResponseType.MISSING_AUTHENTICATION_TOKEN,
+        type: ResponseType.MISSING_AUTHENTICATION_TOKEN,
         statusCode: "404",
         templates: {
-            [mediatypes_1.MediaType.APPLICATION_JSON]: '{"message": "Not found"}',
+            [MediaType.APPLICATION_JSON]: '{"message": "Not found"}',
         },
     });
 }
-exports.add404Support = add404Support;
-function add401Support(restApi, stack) {
-    new aws_apigateway_1.GatewayResponse(stack, `AuthenticationFailedResponse-${restApi.restApiName}`, {
+export function add401Support(restApi, stack) {
+    new GatewayResponse(stack, `AuthenticationFailedResponse-${restApi.restApiName}`, {
         restApi,
-        type: aws_apigateway_1.ResponseType.UNAUTHORIZED,
+        type: ResponseType.UNAUTHORIZED,
         statusCode: "401",
         responseHeaders: {
             "WWW-Authenticate": "'Basic'",
         },
     });
 }
-exports.add401Support = add401Support;
 /**
  * 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.
@@ -156,51 +147,48 @@ exports.add401Support = add401Support;
  * @param restApi RestApi
  * @param stack Construct
  */
-function setReturnCodeForMissingAuthenticationToken(returnCode, message, restApi, stack) {
-    new aws_apigateway_1.GatewayResponse(stack, `MissingAuthenticationTokenResponse-${restApi.restApiName}`, {
+export function setReturnCodeForMissingAuthenticationToken(returnCode, message, restApi, stack) {
+    new GatewayResponse(stack, `MissingAuthenticationTokenResponse-${restApi.restApiName}`, {
         restApi,
-        type: aws_apigateway_1.ResponseType.MISSING_AUTHENTICATION_TOKEN,
+        type: ResponseType.MISSING_AUTHENTICATION_TOKEN,
         statusCode: `${returnCode}`,
         templates: {
-            [mediatypes_1.MediaType.APPLICATION_JSON]: `{"message": ${message}}`,
+            [MediaType.APPLICATION_JSON]: `{"message": ${message}}`,
         },
     });
 }
-exports.setReturnCodeForMissingAuthenticationToken = setReturnCodeForMissingAuthenticationToken;
-function createRestApi(stack, apiId, apiName, allowFromIpAddresses) {
+export function createRestApi(stack, apiId, apiName, allowFromIpAddresses) {
     const policyDocument = allowFromIpAddresses == null
         ? createDefaultPolicyDocument()
         : createIpRestrictionPolicyDocument(allowFromIpAddresses);
-    const restApi = new aws_apigateway_1.RestApi(stack, apiId, {
+    const restApi = new RestApi(stack, apiId, {
         deployOptions: {
-            loggingLevel: aws_apigateway_1.MethodLoggingLevel.ERROR,
+            loggingLevel: MethodLoggingLevel.ERROR,
         },
         restApiName: apiName,
-        endpointTypes: [aws_apigateway_1.EndpointType.REGIONAL],
+        endpointTypes: [EndpointType.REGIONAL],
         policy: policyDocument,
     });
     add404Support(restApi, stack);
     return restApi;
 }
-exports.createRestApi = createRestApi;
-function createDefaultPolicyDocument() {
-    return new aws_iam_1.PolicyDocument({
+export function createDefaultPolicyDocument() {
+    return new PolicyDocument({
         statements: [
-            new aws_iam_1.PolicyStatement({
-                effect: aws_iam_1.Effect.ALLOW,
+            new PolicyStatement({
+                effect: Effect.ALLOW,
                 actions: ["execute-api:Invoke"],
                 resources: ["*"],
-                principals: [new aws_iam_1.AnyPrincipal()],
+                principals: [new AnyPrincipal()],
             }),
         ],
     });
 }
-exports.createDefaultPolicyDocument = createDefaultPolicyDocument;
-function createIpRestrictionPolicyDocument(allowFromIpAddresses) {
-    return new aws_iam_1.PolicyDocument({
+export function createIpRestrictionPolicyDocument(allowFromIpAddresses) {
+    return new PolicyDocument({
         statements: [
-            new aws_iam_1.PolicyStatement({
-                effect: aws_iam_1.Effect.ALLOW,
+            new PolicyStatement({
+                effect: Effect.ALLOW,
                 conditions: {
                     IpAddress: {
                         "aws:SourceIp": allowFromIpAddresses,
@@ -208,10 +196,9 @@ function createIpRestrictionPolicyDocument(allowFromIpAddresses) {
                 },
                 actions: ["execute-api:Invoke"],
                 resources: ["*"],
-                principals: [new aws_iam_1.AnyPrincipal()],
+                principals: [new AnyPrincipal()],
             }),
         ],
     });
 }
-exports.createIpRestrictionPolicyDocument = createIpRestrictionPolicyDocument;
-//# sourceMappingURL=rest_apis.js.map
+//# sourceMappingURL=rest_apis.mjs.map