@digitraffic/common 2025.10.29-2 → 2025.10.30-2

package/dist/__test__/test/mock-ky.test.js

@@ -1,5 +1,5 @@
-import { mockKyResponse } from "../../__test__/mock-ky.js";
 import { describe, jest, test } from "@jest/globals";
+import { mockKyResponse } from "../../__test__/mock-ky.js";
 const ky = (await import("ky")).default;
 describe("mockKyResponse", () => {
     const testObj = { test: "data" };
@@ -9,36 +9,58 @@ describe("mockKyResponse", () => {
         jest.restoreAllMocks();
     });
     test("works with all methods", async () => {
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
-        jest.spyOn(ky, "post").mockImplementation(() => mockKyResponse(200, testJson));
-        jest.spyOn(ky, "put").mockImplementation(() => mockKyResponse(200, testJson));
-        jest.spyOn(ky, "delete").mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "post")
+            .mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "put")
+            .mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "delete")
+            .mockImplementation(() => mockKyResponse(200, testJson));
         expect(await ky.get(url).text()).toEqual(testJson);
         expect(await ky.put(url).text()).toEqual(testJson);
         expect(await ky.post(url).text()).toEqual(testJson);
         expect(await ky.delete(url).text()).toEqual(testJson);
     });
     test("returns correct status", async () => {
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(200, testJson));
         expect((await ky.get(url)).status).toEqual(200);
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(400, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(400, testJson));
         expect((await ky.get(url)).status).toEqual(400);
     });
     test("returns correct ok", async () => {
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(200, testJson));
         expect((await ky.get(url)).ok).toEqual(true);
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(299, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(299, testJson));
         expect((await ky.get(url)).ok).toEqual(true);
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(300, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(300, testJson));
         expect((await ky.get(url)).ok).toEqual(false);
     });
     test("convenience methods work: text", async () => {
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(200, testJson));
         expect(await ky.get(url).text()).toEqual(testJson);
         expect(await (await ky.get(url)).text()).toEqual(testJson);
     });
     test("convenience methods work: json", async () => {
-        jest.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        jest
+            .spyOn(ky, "get")
+            .mockImplementation(() => mockKyResponse(200, testJson));
         expect(await ky.get(url).json()).toEqual(testObj);
         expect(await (await ky.get(url)).json()).toEqual(testObj);
     });

package/dist/__test__/types/lambda-response.test.js

@@ -31,8 +31,7 @@ describe("lambda-response", () => {
         assertJson(response, TEST_JSON, 200, TEST_FILENAME);
     });
     test("okJson - with fileName and timestamp", () => {
-        const response = LambdaResponse.okJson(TEST_JSON, TEST_FILENAME)
-            .withTimestamp(TEST_TIMESTAMP);
+        const response = LambdaResponse.okJson(TEST_JSON, TEST_FILENAME).withTimestamp(TEST_TIMESTAMP);
         assertJson(response, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
     });
     test("okBinary - with fileName and timestamp", () => {

package/dist/__test__/utils/date-utils.test.js

@@ -7,7 +7,7 @@ describe("CommonDateUtilsTest", () => {
         expect(parsed.toISOString()).toEqual(ISO);
     });
     test("dateFromIsoString fails", () => {
-        expect(() => CommonDateUtils.dateFromIsoString(ISO + "foobar")).toThrow();
+        expect(() => CommonDateUtils.dateFromIsoString(`${ISO}foobar`)).toThrow();
     });
     test("countDiffMs", () => {
         const start = new Date();

package/dist/__test__/utils/geometry.test.js

@@ -1,5 +1,5 @@
-import { Asserter } from "../asserter.js";
 import * as Geometry from "../../utils/geometry.js";
+import { Asserter } from "../asserter.js";
 const TAMPERE_WGS84_X = 23.761290078;
 const TAMPERE_WGS84_Y = 61.49774257;
 const KUOPIO_WGS84_X = 27.688935;

package/dist/__test__/utils/logging.test.js

@@ -1,4 +1,4 @@
-import { Writable } from "stream";
+import { Writable } from "node:stream";
 import { DtLogger } from "../../aws/runtime/dt-logger.js";
 import { logException } from "../../utils/logging.js";
 const TEST_METHODNAME = "test.logException";

package/dist/__test__/utils/stop-watch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/utils/stop-watch.test.js

@@ -0,0 +1,118 @@
+import { expect } from "@jest/globals";
+import { StopWatch } from "../../utils/stop-watch.js";
+describe("stop-watch.test.ts", () => {
+    test("StopWatch start-stop", async () => {
+        const sw = new StopWatch().start();
+        await sleepMs(100);
+        sw.stop();
+        expect(sw.getDuration()).toBeGreaterThanOrEqual(95);
+        expect(sw.getDuration()).toBeLessThan(150);
+        sw.logTasks("StopWatchTest.stopWatch");
+    });
+    test("StopWatch with tasks start-stop", async () => {
+        const sw = StopWatch.createStarted();
+        sw.start("task1");
+        await sleepMs(50);
+        sw.stop("task1").start("task2");
+        await sleepMs(100);
+        sw.stop("task2").stop();
+        // total duration should be ~150ms
+        expect(sw.getDuration()).toBeGreaterThanOrEqual(145);
+        expect(sw.getDuration()).toBeLessThan(160);
+        // individual tasks
+        expect(sw.getDuration("task1")).toBeGreaterThanOrEqual(45);
+        expect(sw.getDuration("task1")).toBeLessThan(60);
+        expect(sw.getDuration("task2")).toBeGreaterThanOrEqual(95);
+        expect(sw.getDuration("task2")).toBeLessThan(110);
+        sw.logTasks("StopWatchTest.tasks");
+    });
+    test("StopWatch task with periods", async () => {
+        const sw = StopWatch.createStarted();
+        // period 1
+        sw.start("task1");
+        expect(sw.getTask("task1")?.isRunning).toEqual(true);
+        expect(sw.getTask("task1")?.periods.length).toEqual(1);
+        await sleepMs(50);
+        // period 2
+        sw.start("task1");
+        expect(sw.getTask("task1")?.isRunning).toEqual(true);
+        expect(sw.getTask("task1")?.periods.length).toEqual(2);
+        await sleepMs(100);
+        sw.stop("task1");
+        expect(sw.getTask("task1")?.isRunning).toEqual(false);
+        expect(sw.getTask("task1")?.periods.length).toEqual(2);
+        expect(sw.getTask("task1")?.periods[0]?.duration).toBeGreaterThanOrEqual(45);
+        expect(sw.getTask("task1")?.periods[0]?.duration).toBeLessThan(60);
+        expect(sw.getTask("task1")?.periods[1]?.duration).toBeGreaterThanOrEqual(95);
+        expect(sw.getTask("task1")?.periods[1]?.duration).toBeLessThan(110);
+        expect(sw.getTask("task1")?.totalDuration).toBeGreaterThanOrEqual(145);
+        expect(sw.getTask("task1")?.totalDuration).toBeLessThan(160);
+        expect(sw.getDuration("task1")).toEqual(sw.getTask("task1")?.totalDuration);
+        sw.logTasks("StopWatchTest.periods");
+    });
+    test("StopWatch task with periods", async () => {
+        const sw = StopWatch.createStarted();
+        // period 1
+        sw.start("task1");
+        expect(sw.getTask("task1")?.isRunning).toEqual(true);
+        expect(sw.getTask("task1")?.periods.length).toEqual(1);
+        await sleepMs(50);
+        // period 2
+        sw.start("task1");
+        expect(sw.getTask("task1")?.isRunning).toEqual(true);
+        expect(sw.getTask("task1")?.periods.length).toEqual(2);
+        await sleepMs(100);
+        sw.stop("task1");
+        expect(sw.getTask("task1")?.isRunning).toEqual(false);
+        expect(sw.getTask("task1")?.periods.length).toEqual(2);
+        expect(sw.getTask("task1")?.periods[0]?.duration).toBeGreaterThanOrEqual(45);
+        expect(sw.getTask("task1")?.periods[0]?.duration).toBeLessThan(60);
+        expect(sw.getTask("task1")?.periods[1]?.duration).toBeGreaterThanOrEqual(95);
+        expect(sw.getTask("task1")?.periods[1]?.duration).toBeLessThan(110);
+        expect(sw.getTask("task1")?.totalDuration).toBeGreaterThanOrEqual(145);
+        expect(sw.getTask("task1")?.totalDuration).toBeLessThan(160);
+        expect(sw.getDuration("task1")).toEqual(sw.getTask("task1")?.totalDuration);
+        sw.logTasks("StopWatchTest.periods");
+    });
+    test("StopWatch task not stopped", async () => {
+        const sw = StopWatch.createStarted();
+        await sleepMs(50);
+        // period 1
+        sw.start("task1");
+        await sleepMs(50);
+        expect(sw.getTask("task1")?.isRunning).toEqual(true);
+        expect(sw.getDuration()).toBeGreaterThanOrEqual(95);
+        expect(sw.getDuration()).toBeLessThan(110);
+        expect(sw.getDuration("task1")).toBeGreaterThanOrEqual(45);
+        expect(sw.getDuration("task1")).toBeLessThan(55);
+        sw.logTasks("StopWatchTest.notStopped");
+    });
+    test("StopWatch reset", async () => {
+        const sw = StopWatch.createStarted();
+        await sleepMs(50);
+        // period 1
+        sw.start("task1");
+        sw.start("task2");
+        await sleepMs(50);
+        // reset tassk2 should not affect task1
+        sw.reset("task2");
+        expect(sw.getTask("task2")).toBeUndefined();
+        expect(sw.getTask("task1")?.isRunning).toEqual(true);
+        expect(sw.getDuration()).toBeGreaterThanOrEqual(95);
+        expect(sw.getDuration()).toBeLessThan(110);
+        expect(sw.getDuration("task1")).toBeGreaterThanOrEqual(45);
+        expect(sw.getDuration("task1")).toBeLessThan(55);
+        // Reset only task1
+        sw.reset("task1");
+        expect(sw.getTask("task1")).toBeUndefined();
+        expect(sw.getDuration()).toBeGreaterThanOrEqual(95);
+        expect(sw.getDuration()).toBeLessThan(110);
+        // Reset also default task
+        sw.reset();
+        expect(sw.getDuration()).toEqual(0);
+    });
+});
+function sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=stop-watch.test.js.map

package/dist/__test__/utils/utils.test.js

@@ -11,8 +11,7 @@ describe("ArrayUtils", () => {
         expect(ArrayUtils.bothArraysHasSameValues(["a"], undefined)).toEqual(false);
         expect(ArrayUtils.bothArraysHasSameValues(["a"], null)).toEqual(false);
         expect(ArrayUtils.bothArraysHasSameValues(["a", "b"], ["a", "a"])).toEqual(false);
-        expect(ArrayUtils.bothArraysHasSameValues(["a", "a", "a"], ["a", "b", "c"]))
-            .toEqual(false);
+        expect(ArrayUtils.bothArraysHasSameValues(["a", "a", "a"], ["a", "b", "c"])).toEqual(false);
         const o1 = { a: 1, b: 2 };
         const o2 = { a: 1, b: 2 };
         // Objects are references to same
@@ -41,9 +40,7 @@ describe("ArrayUtils", () => {
     });
     test("isDefined", () => {
         expect([1, 2, undefined, null, 3].filter(ArrayUtils.isDefined)).toEqual([
-            1,
-            2,
-            3,
+            1, 2, 3,
         ]);
     });
 });

package/dist/aws/infra/acl-builder.js

@@ -1,6 +1,6 @@
 import { CfnIPSet, CfnWebACL } from "aws-cdk-lib/aws-wafv2";
-import { logger } from "../runtime/dt-logger-default.js";
 import { concat, range, zipWith } from "lodash-es";
+import { logger } from "../runtime/dt-logger-default.js";
 /**
  * Builder class for building CfnWebACL.
  *
@@ -327,7 +327,7 @@ function createThrottleStatement(limit, isHeaderRequired, isBasedOnIpAndUriPath,
                 aggregateKeyType: "CUSTOM_KEYS",
                 customKeys: CUSTOM_KEYS_IP_AND_URI_PATH,
                 limit: limit,
-                scopeDownStatement
+                scopeDownStatement,
             },
         };
     }
@@ -335,7 +335,7 @@ function createThrottleStatement(limit, isHeaderRequired, isBasedOnIpAndUriPath,
         rateBasedStatement: {
             aggregateKeyType: "IP",
             limit: limit,
-            scopeDownStatement
+            scopeDownStatement,
         },
     };
 }

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

@@ -1,4 +1,5 @@
-import { type IntegrationResponse, LambdaIntegration } from "aws-cdk-lib/aws-apigateway";
+import type { IntegrationResponse } from "aws-cdk-lib/aws-apigateway";
+import { LambdaIntegration } from "aws-cdk-lib/aws-apigateway";
 import type { IFunction } from "aws-cdk-lib/aws-lambda";
 import { MediaType } from "../../types/mediatypes.js";
 type ParameterType = "path" | "querystring" | "multivaluequerystring" | "context" | "header";

package/dist/aws/infra/api/integration.js

@@ -1,6 +1,6 @@
 import { LambdaIntegration, PassthroughBehavior, } from "aws-cdk-lib/aws-apigateway";
-import { MediaType } from "../../types/mediatypes.js";
 import { DigitrafficIntegrationResponse } from "../../runtime/digitraffic-integration-response.js";
+import { MediaType } from "../../types/mediatypes.js";
 const VELOCITY_ALL_PARAMS = `#foreach($paramName in $params.keySet())
     #if( ! $paramMap.containsKey("_$paramName"))
         #set($tmp = $paramMap.put($paramName, $params[$paramName]))
@@ -48,18 +48,24 @@ export class DigitrafficIntegration {
         return this;
     }
     addPathParameter(...names) {
-        names.forEach((name) => this.addParameter("path", name));
+        names.forEach((name) => {
+            this.addParameter("path", name);
+        });
         return this;
     }
     addQueryParameter(...names) {
         if (this._passAllQueryParameters) {
             throw new Error("Can't add query parameters with pass all");
         }
-        names.forEach((name) => this.addParameter("querystring", name));
+        names.forEach((name) => {
+            this.addParameter("querystring", name);
+        });
         return this;
     }
     addMultiValueQueryParameter(...names) {
-        names.forEach((name) => this.addParameter("multivaluequerystring", name));
+        names.forEach((name) => {
+            this.addParameter("multivaluequerystring", name);
+        });
         return this;
     }
     /**
@@ -69,7 +75,9 @@ export class DigitrafficIntegration {
      * @returns
      */
     addContextParameter(...names) {
-        names.forEach((name) => this.addParameter("context", name));
+        names.forEach((name) => {
+            this.addParameter("context", name);
+        });
         return this;
     }
     /**
@@ -78,7 +86,9 @@ export class DigitrafficIntegration {
      * @param names for the headers
      */
     addHeaderParameter(...names) {
-        names.forEach((name) => this.addParameter("header", name));
+        names.forEach((name) => {
+            this.addParameter("header", name);
+        });
         return this;
     }
     build() {
@@ -93,6 +103,7 @@ export class DigitrafficIntegration {
             passthroughBehavior: PassthroughBehavior.WHEN_NO_MATCH,
         });
     }
+    // noinspection JSUnusedGlobalSymbols
     createRequestParameters() {
         const requestParameters = {};
         // filter out context parameters

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

@@ -1,5 +1,5 @@
+import type { IModel, JsonSchema, MethodResponse } from "aws-cdk-lib/aws-apigateway";
 import { MediaType } from "../../types/mediatypes.js";
-import { type IModel, type JsonSchema, type MethodResponse } from "aws-cdk-lib/aws-apigateway";
 /**
  * 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
@@ -21,27 +21,42 @@ export declare const RESPONSE_DEFAULT_LAMBDA = "#set($inputRoot = $input.path('$
  * @param sunset Sunset date as string in ISO 8601 date-time format (YYYY-MM-DD)
  */
 export declare const getDeprecatedDefaultLambdaResponse: (sunset?: string) => string;
+/**
+ * @deprecated
+ */
 export declare const MessageModel: {
     contentType: MediaType;
     modelName: string;
     schema: JsonSchema;
 };
 export declare const NotFoundResponse: string;
+/**
+ * @deprecated
+ */
 export declare const BadRequestResponseTemplate: {
     "application/json": string;
 };
+/**
+ * @deprecated
+ */
 export declare const NotFoundResponseTemplate: {
     "application/json": string;
 };
+/**
+ * @deprecated
+ */
 export declare const XmlResponseTemplate: {
     "application/xml": string;
 };
+/**
+ * @deprecated
+ */
 export declare const InternalServerErrorResponseTemplate: {
     "application/json": string;
 };
-export declare class DigitrafficMethodResponse {
-    static response(statusCode: string, model: IModel, mediaType: MediaType, disableCors?: boolean, deprecation?: boolean, sunset?: boolean): MethodResponse;
-    static response200(model: IModel, mediaType?: MediaType, deprecation?: boolean, sunset?: boolean): MethodResponse;
-    static response500(model?: IModel, mediaType?: MediaType): MethodResponse;
-    static response400(model?: IModel, mediaType?: MediaType): MethodResponse;
-}
+export declare const DigitrafficMethodResponse: {
+    response(statusCode: string, model: IModel, mediaType: MediaType, disableCors?: boolean, deprecation?: boolean, sunset?: boolean): MethodResponse;
+    response200(model: IModel, mediaType?: MediaType, deprecation?: boolean, sunset?: boolean): MethodResponse;
+    response500(model?: IModel, mediaType?: MediaType): MethodResponse;
+    response400(model?: IModel, mediaType?: MediaType): MethodResponse;
+};

package/dist/aws/infra/api/response.js

@@ -1,6 +1,6 @@
-import { MediaType } from "../../types/mediatypes.js";
 import { JsonSchemaType, JsonSchemaVersion, Model, } from "aws-cdk-lib/aws-apigateway";
 import { dateFromIsoString } from "../../../utils/date-utils.js";
+import { MediaType } from "../../types/mediatypes.js";
 /**
  * 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
@@ -45,7 +45,9 @@ export const getDeprecatedDefaultLambdaResponse = (sunset) => {
     return RESPONSE_DEFAULT_LAMBDA.concat(setDeprecationHeaders);
 };
 const BODY_FROM_INPUT_PATH = "$input.path('$').body";
-/// @deprecated
+/**
+ * @deprecated
+ */
 const messageSchema = {
     schema: JsonSchemaVersion.DRAFT4,
     type: JsonSchemaType.OBJECT,
@@ -57,7 +59,9 @@ const messageSchema = {
         },
     },
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const MessageModel = {
     contentType: MediaType.APPLICATION_JSON,
     modelName: "MessageResponseModel",
@@ -71,24 +75,32 @@ const InternalServerErrorResponse = JSON.stringify({
 });
 const BadRequestMessage = "Bad request";
 const BadRequestResponse = JSON.stringify({ message: BadRequestMessage });
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const BadRequestResponseTemplate = {
     [MediaType.APPLICATION_JSON]: BadRequestResponse,
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const NotFoundResponseTemplate = {
     [MediaType.APPLICATION_JSON]: NotFoundResponse,
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const XmlResponseTemplate = {
     [MediaType.APPLICATION_XML]: BODY_FROM_INPUT_PATH,
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const InternalServerErrorResponseTemplate = {
     [MediaType.APPLICATION_JSON]: InternalServerErrorResponse,
 };
-export class DigitrafficMethodResponse {
-    static response(statusCode, model, mediaType, disableCors = false, deprecation = false, sunset = false) {
+export const DigitrafficMethodResponse = {
+    response(statusCode, model, mediaType, disableCors = false, deprecation = false, sunset = false) {
         return {
             statusCode,
             responseModels: {
@@ -106,15 +118,15 @@ export class DigitrafficMethodResponse {
                 }),
             },
         };
-    }
-    static response200(model, mediaType = MediaType.APPLICATION_JSON, deprecation = false, sunset = false) {
+    },
+    response200(model, mediaType = MediaType.APPLICATION_JSON, deprecation = false, sunset = false) {
         return DigitrafficMethodResponse.response("200", model, mediaType, false, deprecation, sunset);
-    }
-    static response500(model = Model.EMPTY_MODEL, mediaType = MediaType.APPLICATION_JSON) {
+    },
+    response500(model = Model.EMPTY_MODEL, mediaType = MediaType.APPLICATION_JSON) {
         return DigitrafficMethodResponse.response("500", model, mediaType, false);
-    }
-    static response400(model = Model.EMPTY_MODEL, mediaType = MediaType.APPLICATION_JSON) {
+    },
+    response400(model = Model.EMPTY_MODEL, mediaType = MediaType.APPLICATION_JSON) {
         return DigitrafficMethodResponse.response("400", model, mediaType, false);
-    }
-}
+    },
+};
 //# sourceMappingURL=response.js.map

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

@@ -1,14 +1,30 @@
-import { type IModel, type IntegrationResponse, LambdaIntegration, type MethodResponse, PassthroughBehavior } from "aws-cdk-lib/aws-apigateway";
+import type { IModel, IntegrationResponse, MethodResponse } from "aws-cdk-lib/aws-apigateway";
+import { LambdaIntegration, PassthroughBehavior } from "aws-cdk-lib/aws-apigateway";
 import type { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
 import type { MediaType } from "../../types/mediatypes.js";
+/**
+ * @deprecated
+ */
 export declare const RESPONSE_200_OK: IntegrationResponse;
+/**
+ * @deprecated
+ */
 export declare const RESPONSE_400_BAD_REQUEST: IntegrationResponse;
+/**
+ * @deprecated
+ */
 export declare const RESPONSE_500_SERVER_ERROR: IntegrationResponse;
+/**
+ * @deprecated
+ */
 export declare const RESPONSE_CORS_INTEGRATION: {
     responseParameters: {
         "method.response.header.Access-Control-Allow-Origin": string;
     };
 };
+/**
+ * @deprecated
+ */
 export declare const RESPONSE_404_NOT_FOUND: {
     statusCode: string;
     selectionPattern: string;

package/dist/aws/infra/api/responses.js

@@ -1,33 +1,45 @@
-import { BadRequestResponseTemplate, InternalServerErrorResponseTemplate, NotFoundResponseTemplate, XmlResponseTemplate, } from "./response.js";
 import { LambdaIntegration, PassthroughBehavior, } from "aws-cdk-lib/aws-apigateway";
 import { BAD_REQUEST_MESSAGE, ERROR_MESSAGE, NOT_FOUND_MESSAGE, } from "../../types/errors.js";
-/// @deprecated
+import { BadRequestResponseTemplate, InternalServerErrorResponseTemplate, NotFoundResponseTemplate, XmlResponseTemplate, } from "./response.js";
+/**
+ * @deprecated
+ */
 export const RESPONSE_200_OK = {
     statusCode: "200",
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const RESPONSE_400_BAD_REQUEST = {
     statusCode: "400",
     selectionPattern: BAD_REQUEST_MESSAGE,
     responseTemplates: BadRequestResponseTemplate,
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const RESPONSE_500_SERVER_ERROR = {
     statusCode: "500",
     selectionPattern: ERROR_MESSAGE,
     responseTemplates: InternalServerErrorResponseTemplate,
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 const RESPONSE_XML = {
     responseTemplates: XmlResponseTemplate,
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const RESPONSE_CORS_INTEGRATION = {
     responseParameters: {
         "method.response.header.Access-Control-Allow-Origin": "'*'",
     },
 };
-/// @deprecated
+/**
+ * @deprecated
+ */
 export const RESPONSE_404_NOT_FOUND = {
     statusCode: "404",
     selectionPattern: NOT_FOUND_MESSAGE,
@@ -63,8 +75,7 @@ export function defaultIntegration(lambdaFunction, options) {
         ],
         requestParameters: options?.requestParameters ?? {},
         requestTemplates: options?.requestTemplates ?? {},
-        passthroughBehavior: options?.passthroughBehavior ??
-            PassthroughBehavior.WHEN_NO_MATCH,
+        passthroughBehavior: options?.passthroughBehavior ?? PassthroughBehavior.WHEN_NO_MATCH,
     });
 }
 export function getResponse(response, options) {

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

@@ -1,4 +1,5 @@
-import { type IModel, type IntegrationResponse, type MethodResponse, MockIntegration, type Resource } from "aws-cdk-lib/aws-apigateway";
+import type { IModel, IntegrationResponse, MethodResponse, Resource } from "aws-cdk-lib/aws-apigateway";
+import { MockIntegration } from "aws-cdk-lib/aws-apigateway";
 import { MediaType } from "../../types/mediatypes.js";
 /**
  * Static integration, that returns the given response with given mediaType from given resource.

package/dist/aws/infra/api/static-integration.js

@@ -15,8 +15,7 @@ export class DigitrafficStaticIntegration extends MockIntegration {
         if (enableCors) {
             headers = { ...headers, "Access-Control-Allow-Origin": "*" };
         }
-        const integrationResponse = DigitrafficStaticIntegration
-            .createIntegrationResponse(response, mediaType, headers);
+        const integrationResponse = DigitrafficStaticIntegration.createIntegrationResponse(response, mediaType, headers);
         super({
             passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES,
             requestTemplates: {
@@ -37,7 +36,10 @@ export class DigitrafficStaticIntegration extends MockIntegration {
         return new DigitrafficStaticIntegration(resource, MediaType.APPLICATION_JSON, JSON.stringify(response), model, enableCors, apiKeyRequired, headers);
     }
     static createIntegrationResponse(response, mediaType, headers = {}) {
-        const params = mapRecord(headers, (entry) => ["method.response.header." + entry[0], `'${entry[1]}'`]);
+        const params = mapRecord(headers, (entry) => [
+            `method.response.header.${entry[0]}`,
+            `'${entry[1]}'`,
+        ]);
         return {
             statusCode: "200",
             responseTemplates: {

package/dist/aws/infra/bucket-policy.js

@@ -6,10 +6,10 @@ export function grantOACRights(config) {
     config.bucket.addToResourcePolicy(new PolicyStatement({
         effect: config.effect ?? Effect.ALLOW,
         principals: [new ServicePrincipal("cloudfront.amazonaws.com")],
-        resources: config.resources ?? [config.bucket.bucketArn + "/*"],
+        resources: config.resources ?? [`${config.bucket.bucketArn}/*`],
         actions: config.actions ?? ["s3:GetObject"],
         conditions: {
-            "StringEquals": {
+            StringEquals: {
                 "AWS:SourceArn": config.distributionArn,
             },
         },
@@ -23,7 +23,7 @@ export function grantOAIRights(config) {
     config.bucket.addToResourcePolicy(new PolicyStatement({
         effect: config.effect ?? Effect.ALLOW,
         principals: [new CanonicalUserPrincipal(config.canonicalUserId)],
-        resources: config.resources ?? [config.bucket.bucketArn + "/*"],
+        resources: config.resources ?? [`${config.bucket.bucketArn}/*`],
         actions: config.actions ?? ["s3:GetObject"],
     }));
 }

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

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