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

package/dist/__test__/stack/rest-apis.test.d.ts

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

package/dist/__test__/stack/rest-apis.test.js

@@ -0,0 +1,45 @@
+import { App } from "aws-cdk-lib";
+import { Match, Template } from "aws-cdk-lib/assertions";
+import { describe, test } from "vitest";
+import { DigitrafficRestApi } from "../../aws/infra/stack/rest-api.js";
+import { DigitrafficStack } from "../../aws/infra/stack/stack.js";
+import { TrafficType } from "../../types/traffictype.js";
+describe("Rest api test", () => {
+    test("OPTIONS method is added to API-gateway", () => {
+        const app = new App();
+        const stack = new DigitrafficStack(app, "test-stack", {
+            alarmTopicArn: "",
+            production: false,
+            shortName: "test",
+            stackProps: {},
+            trafficType: TrafficType.ROAD,
+            warningTopicArn: "",
+        });
+        const publicApi = new DigitrafficRestApi(stack, "test", "testName");
+        const apiResource = publicApi.root.addResource("api");
+        const versionResource = apiResource.addResource("v1");
+        const testsResource = publicApi.addResourceWithCorsOptionsSubTree(versionResource, "tests");
+        testsResource.addResource("{testId}");
+        const template = Template.fromStack(stack);
+        template.resourcePropertiesCountIs("AWS::ApiGateway::Method", {
+            HttpMethod: "OPTIONS",
+        }, 2);
+        template.hasResource("AWS::ApiGateway::Method", {
+            Properties: {
+                HttpMethod: "OPTIONS",
+                Integration: {
+                    IntegrationResponses: Match.arrayWith([
+                        Match.objectLike({
+                            ResponseParameters: Match.objectEquals({
+                                "method.response.header.Access-Control-Allow-Headers": "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,Digitraffic-User'",
+                                "method.response.header.Access-Control-Allow-Origin": "'*'",
+                                "method.response.header.Access-Control-Allow-Methods": "'OPTIONS,GET,HEAD'",
+                            }),
+                        }),
+                    ]),
+                },
+            },
+        });
+    });
+});
+//# sourceMappingURL=rest-apis.test.js.map

package/dist/__test__/test/mock-ky.test.d.ts

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

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

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { mockKyResponse } from "../../__test__/mock-ky.js";
+const ky = (await import("ky")).default;
+describe("mockKyResponse", () => {
+    const testObj = { test: "data" };
+    const testJson = JSON.stringify(testObj);
+    const url = "https://example.com";
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    test("works with all methods", async () => {
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        vi.spyOn(ky, "post").mockImplementation(() => mockKyResponse(200, testJson));
+        vi.spyOn(ky, "put").mockImplementation(() => mockKyResponse(200, testJson));
+        vi.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 () => {
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        expect((await ky.get(url)).status).toEqual(200);
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(400, testJson));
+        expect((await ky.get(url)).status).toEqual(400);
+    });
+    test("returns correct ok", async () => {
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        expect((await ky.get(url)).ok).toEqual(true);
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(299, testJson));
+        expect((await ky.get(url)).ok).toEqual(true);
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(300, testJson));
+        expect((await ky.get(url)).ok).toEqual(false);
+    });
+    test("convenience methods work: text", async () => {
+        vi.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 () => {
+        vi.spyOn(ky, "get").mockImplementation(() => mockKyResponse(200, testJson));
+        expect(await ky.get(url).json()).toEqual(testObj);
+        expect(await (await ky.get(url)).json()).toEqual(testObj);
+    });
+});
+//# sourceMappingURL=mock-ky.test.js.map

package/dist/__test__/testutils.d.ts

@@ -0,0 +1,12 @@
+export declare function randomString(): string;
+export declare function getRandomNumber(min: number, max: number): number;
+export declare function getRandomNumberAsString(min: number, max: number): string;
+export declare function getRandomInteger(min: number, max: number): number;
+export declare function getRandomIntegerAsString(min: number, max: number): string;
+export declare function getRandomBigInt(min: number, max: number): bigint;
+export declare function randomBoolean(): boolean;
+/**
+ * Returns a new copy of an array, shuffled using Math.random()
+ * @param array Array
+ */
+export declare function shuffle<T>(array: T[]): T[];

package/dist/__test__/testutils.js

@@ -0,0 +1,32 @@
+export function randomString() {
+    return Math.random().toString(36).substring(2);
+}
+export function getRandomNumber(min, max) {
+    return Math.random() * (max - min) + min;
+}
+export function getRandomNumberAsString(min, max) {
+    return getRandomNumber(min, max).toString();
+}
+export function getRandomInteger(min, max) {
+    return Math.round(getRandomNumber(min, max));
+}
+export function getRandomIntegerAsString(min, max) {
+    return Math.round(getRandomInteger(min, max)).toString();
+}
+export function getRandomBigInt(min, max) {
+    return BigInt(getRandomInteger(min, max));
+}
+export function randomBoolean() {
+    return Math.random() < 0.5;
+}
+/**
+ * Returns a new copy of an array, shuffled using Math.random()
+ * @param array Array
+ */
+export function shuffle(array) {
+    // pretty fast way to copy an array, not necessarily the fastest
+    const newArray = array.slice(0);
+    newArray.sort((_) => 0.5 - Math.random());
+    return newArray;
+}
+//# sourceMappingURL=testutils.js.map

package/dist/__test__/types/lambda-proxy-types.test.d.ts

@@ -0,0 +1,8 @@
+export declare const TEST_BIG_JSON: {
+    items: {
+        id: number;
+        name: string;
+        description: string;
+        value: number;
+    }[];
+};

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

@@ -0,0 +1,155 @@
+import { describe, expect, test } from "vitest";
+import { LambdaProxyResponseBuilder } from "../../aws/types/lambda-proxy-types.js";
+import { MediaType } from "../../aws/types/mediatypes.js";
+import { decodeBase64ToUtf8 } from "../../utils/base64.js";
+// About 18 MB will be compressed to 2 MB
+export const TEST_BIG_JSON = {
+    items: Array.from({ length: 10 }, (_, i) => ({
+        id: i,
+        name: `Item ${i}`,
+        description: "This is a test description that repeats to allow compression",
+        value: Math.random(),
+    })),
+};
+describe("lambda-response", () => {
+    const TEST_MESSAGE = "HELLO";
+    const TEST_COUNT = 12;
+    const TEST_FILENAME = "file.txt";
+    const TEST_TIMESTAMP = new Date();
+    const TEST_TIMESTAMP_STR = TEST_TIMESTAMP.toISOString();
+    const TEST_JSON = {
+        message: TEST_MESSAGE,
+        count: TEST_COUNT,
+    };
+    function isCompressed(response) {
+        return response.headers?.["Content-Encoding"] === "gzip";
+    }
+    function assertContent(response, expectedBody, expectedStatus, expectedFilename, expectedTimestamp, expectContentType = MediaType.APPLICATION_JSON, compressed = false, isBase64Encoded = false) {
+        const isBinary = typeof expectedBody !== "string";
+        const decodedBody = response.isBase64Encoded
+            ? decodeBase64ToUtf8(response.body, isCompressed(response))
+            : response.body;
+        const body = isBinary ? JSON.parse(decodedBody) : decodedBody;
+        expect(body).toEqual(expectedBody);
+        // compressed responses are always base64 encoded
+        expect(response.isBase64Encoded).toEqual(compressed || isBase64Encoded);
+        expect(response.statusCode).toEqual(expectedStatus);
+        if (expectedFilename) {
+            expect(response.headers?.["Content-Disposition"]).toEqual(`attachment; filename="${expectedFilename}"`);
+        }
+        else {
+            expect(response.headers?.["Content-Disposition"]).toBeUndefined();
+        }
+        if (expectedTimestamp) {
+            expect(response.headers?.["Last-Modified"]).toEqual(expectedTimestamp?.toUTCString());
+        }
+        else {
+            expect(response.headers?.["Last-Modified"]).toBeUndefined();
+        }
+        if (compressed) {
+            expect(response.headers?.["Content-Encoding"]).toEqual("gzip");
+        }
+        else {
+            // No content-encoding header for uncompressed content
+            expect(response.headers?.["Content-Encoding"]).toBeUndefined();
+        }
+        expect(response.headers?.["Content-Type"]).toEqual(expectContentType);
+    }
+    test("okJson - create json", () => {
+        const response = LambdaProxyResponseBuilder.create(TEST_JSON).build();
+        assertContent(response, TEST_JSON, 200);
+    });
+    test("okJson - with json", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .build();
+        assertContent(response, TEST_JSON, 200);
+    });
+    test("okJson - with json and fileName", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .build();
+        assertContent(response, TEST_JSON, 200, TEST_FILENAME);
+    });
+    test("okJson - with json, fileName and timestamp", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .build();
+        const response2 = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP_STR)
+            .build();
+        assertContent(response, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
+        assertContent(response2, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
+    });
+    test("okBinary - create binary, fileName and timestamp", () => {
+        const response = LambdaProxyResponseBuilder.create(Buffer.from(TEST_MESSAGE).toString("base64"), true)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .withContentType(MediaType.TEXT_PLAIN)
+            .build();
+        assertContent(response, TEST_MESSAGE, 200, TEST_FILENAME, TEST_TIMESTAMP, MediaType.TEXT_PLAIN, false, true);
+    });
+    test("badRequest", () => {
+        const response = LambdaProxyResponseBuilder.badRequest(TEST_MESSAGE);
+        assertContent(response, TEST_MESSAGE, 400, undefined, undefined, MediaType.TEXT_PLAIN);
+    });
+    test("notFound", () => {
+        const response = LambdaProxyResponseBuilder.notFound();
+        assertContent(response, "Not Found", 404, undefined, undefined, MediaType.TEXT_PLAIN);
+    });
+    test("internalError", () => {
+        const response = LambdaProxyResponseBuilder.internalError();
+        assertContent(response, "Internal Error", 500, undefined, undefined, MediaType.TEXT_PLAIN);
+    });
+    test("notImplemented", () => {
+        const response = LambdaProxyResponseBuilder.notImplemented();
+        assertContent(response, "Not Implemented", 501, undefined, undefined, MediaType.TEXT_PLAIN);
+    });
+    test("notImplemented", () => {
+        const response = LambdaProxyResponseBuilder.unauthorized();
+        assertContent(response, "Unauthorized", 401, undefined, undefined, MediaType.TEXT_PLAIN);
+    });
+    test("okText - with fileName and timestamp", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_MESSAGE)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .build();
+        assertContent(response, TEST_MESSAGE, 200, TEST_FILENAME, TEST_TIMESTAMP);
+    });
+    test("okJson - compression uneffective for small json", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .withCompression()
+            .withDebug()
+            .build();
+        assertContent(response, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP, MediaType.APPLICATION_JSON, false);
+    });
+    test("okJson - compression effective for large json", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(TEST_BIG_JSON)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .withCompression()
+            .withDebug()
+            .build();
+        assertContent(response, TEST_BIG_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP, MediaType.APPLICATION_JSON, true);
+    });
+    test("okText - as binary", () => {
+        const response = LambdaProxyResponseBuilder.create()
+            .withBody(Buffer.from(TEST_MESSAGE).toString("base64"), true)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .withContentType(MediaType.TEXT_PLAIN)
+            .build();
+        assertContent(response, TEST_MESSAGE, 200, TEST_FILENAME, TEST_TIMESTAMP, MediaType.TEXT_PLAIN, false, true);
+    });
+});
+//# sourceMappingURL=lambda-proxy-types.test.js.map

package/dist/__test__/types/lambda-response-builder.test.d.ts

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

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

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "vitest";
+import { LambdaResponseBuilder } from "../../aws/types/lambda-response.js";
+import { decodeBase64ToUtf8 } from "../../utils/base64.js";
+import { TEST_FILENAME, TEST_JSON, TEST_MESSAGE, TEST_TIMESTAMP, TEST_TIMESTAMP_STR, } from "./lambda-response.test.js";
+describe("lambda-response", () => {
+    function assertJson(response, expectedJson, expectedStatus, expectedFilename, expectedTimestamp) {
+        const body = JSON.parse(decodeBase64ToUtf8(response.body));
+        expect(body).toEqual(expectedJson);
+        expect(response.status).toEqual(expectedStatus);
+        expect(response.fileName).toEqual(expectedFilename);
+        expect(response.timestamp).toEqual(expectedTimestamp?.toUTCString());
+    }
+    function assertBinary(response, expectedString, expectedStatus, expectedFilename, expectedTimestamp) {
+        const body = decodeBase64ToUtf8(response.body);
+        expect(body).toEqual(expectedString);
+        expect(response.status).toEqual(expectedStatus);
+        expect(response.fileName).toEqual(expectedFilename);
+        expect(response.timestamp).toEqual(expectedTimestamp?.toUTCString());
+    }
+    test("okJson - without fileName", () => {
+        const response = LambdaResponseBuilder.create(TEST_JSON).build();
+        assertJson(response, TEST_JSON, 200);
+    });
+    test("okJson - with fileName", () => {
+        const response = LambdaResponseBuilder.create(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .build();
+        assertJson(response, TEST_JSON, 200, TEST_FILENAME);
+    });
+    test("okJson - with fileName and timestamp", () => {
+        const responseWithTimestampDate = LambdaResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .build();
+        const responseWithTimestampString = LambdaResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP_STR)
+            .build();
+        assertJson(responseWithTimestampDate, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
+        assertJson(responseWithTimestampString, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
+    });
+    test("okBinary - with fileName and timestamp", () => {
+        const response = LambdaResponseBuilder.create()
+            .withBody(TEST_MESSAGE)
+            .withFileName(TEST_FILENAME)
+            .withTimestamp(TEST_TIMESTAMP)
+            .build();
+        assertBinary(response, TEST_MESSAGE, 200, TEST_FILENAME, TEST_TIMESTAMP);
+    });
+    test("badRequest", () => {
+        const response = LambdaResponseBuilder.badRequest(TEST_MESSAGE);
+        assertBinary(response, TEST_MESSAGE, 400);
+    });
+    test("notFound", () => {
+        const response = LambdaResponseBuilder.notFound();
+        assertBinary(response, "Not Found", 404);
+    });
+    test("internalError", () => {
+        const response = LambdaResponseBuilder.internalError();
+        assertBinary(response, "Internal Error", 500);
+    });
+    test("notImplemented", () => {
+        const response = LambdaResponseBuilder.notImplemented();
+        assertBinary(response, "Not Implemented", 501);
+    });
+    // Builder
+    test("Builder - okJson - without fileName", () => {
+        const response = LambdaResponseBuilder.create().withBody(TEST_JSON).build();
+        assertJson(response, TEST_JSON, 200);
+    });
+    test("Builder - okJson - with fileName", () => {
+        const response = LambdaResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .build();
+        assertJson(response, TEST_JSON, 200, TEST_FILENAME);
+    });
+});
+//# sourceMappingURL=lambda-response-builder.test.js.map

package/dist/__test__/types/lambda-response.test.d.ts

@@ -0,0 +1,9 @@
+export declare const TEST_MESSAGE = "HELLO";
+export declare const TEST_COUNT = 12;
+export declare const TEST_FILENAME = "file.txt";
+export declare const TEST_TIMESTAMP: Date;
+export declare const TEST_TIMESTAMP_STR: string;
+export declare const TEST_JSON: {
+    message: string;
+    count: number;
+};

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

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "vitest";
+import { LambdaResponse, LambdaResponseBuilder, } from "../../aws/types/lambda-response.js";
+import { decodeBase64ToUtf8 } from "../../utils/base64.js";
+export const TEST_MESSAGE = "HELLO";
+export const TEST_COUNT = 12;
+export const TEST_FILENAME = "file.txt";
+export const TEST_TIMESTAMP = new Date();
+export const TEST_TIMESTAMP_STR = TEST_TIMESTAMP.toISOString();
+export const TEST_JSON = {
+    message: TEST_MESSAGE,
+    count: TEST_COUNT,
+};
+describe("lambda-response", () => {
+    function assertJson(response, expectedJson, expectedStatus, expectedFilename, expectedTimestamp) {
+        const body = JSON.parse(decodeBase64ToUtf8(response.body));
+        expect(body).toEqual(expectedJson);
+        expect(response.status).toEqual(expectedStatus);
+        expect(response.fileName).toEqual(expectedFilename);
+        expect(response.timestamp).toEqual(expectedTimestamp?.toUTCString());
+    }
+    function assertBinary(response, expectedString, expectedStatus, expectedFilename, expectedTimestamp) {
+        const body = decodeBase64ToUtf8(response.body);
+        expect(body).toEqual(expectedString);
+        expect(response.status).toEqual(expectedStatus);
+        expect(response.fileName).toEqual(expectedFilename);
+        expect(response.timestamp).toEqual(expectedTimestamp?.toUTCString());
+    }
+    test("okJson - without fileName", () => {
+        const response = LambdaResponse.okJson(TEST_JSON);
+        assertJson(response, TEST_JSON, 200);
+    });
+    test("okJson - with fileName", () => {
+        const response = LambdaResponse.okJson(TEST_JSON, TEST_FILENAME);
+        assertJson(response, TEST_JSON, 200, TEST_FILENAME);
+    });
+    test("okJson - with fileName and 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", () => {
+        const response = LambdaResponse.okBinary(Buffer.from(TEST_MESSAGE).toString("base64"), TEST_FILENAME).withTimestamp(TEST_TIMESTAMP);
+        assertBinary(response, TEST_MESSAGE, 200, TEST_FILENAME, TEST_TIMESTAMP);
+    });
+    test("badRequest", () => {
+        const response = LambdaResponse.badRequest(TEST_MESSAGE);
+        assertBinary(response, TEST_MESSAGE, 400);
+    });
+    test("notFound", () => {
+        const response = LambdaResponse.notFound();
+        assertBinary(response, "Not Found", 404);
+    });
+    test("internalError", () => {
+        const response = LambdaResponse.internalError();
+        assertBinary(response, "Internal Error", 500);
+    });
+    test("notImplemented", () => {
+        const response = LambdaResponse.notImplemented();
+        assertBinary(response, "Not Implemented", 501);
+    });
+    // Builder
+    test("Builder - okJson - without fileName", () => {
+        const response = LambdaResponseBuilder.create().withBody(TEST_JSON).build();
+        assertJson(response, TEST_JSON, 200);
+    });
+    test("Builder - okJson - with fileName", () => {
+        const response = LambdaResponseBuilder.create()
+            .withBody(TEST_JSON)
+            .withFileName(TEST_FILENAME)
+            .build();
+        assertJson(response, TEST_JSON, 200, TEST_FILENAME);
+    });
+});
+//# sourceMappingURL=lambda-response.test.js.map

package/dist/__test__/utils/base64.test.d.ts

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

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

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "vitest";
+import { compressBuffer, decodeBase64ToAscii, decodeBase64ToUtf8, encodeAsciiToBase64, encodeUtf8ToBase64, } from "../../utils/base64.js";
+describe("Base64UtilTest", () => {
+    const EXPECTED_ASCII = "0a9f4967-faaa-445a-ba11-078f7f9556b4";
+    const EXPECTED_ASCII_BASE64 = "MGE5ZjQ5NjctZmFhYS00NDVhLWJhMTEtMDc4ZjdmOTU1NmI0";
+    const EXPECTED_UTF8 = '욤頶ɠ_񝝉T񶅶𞜫7郣Ҧ㒢,"鏤ځ峡蟅͆뼐񭫟ؐԓ外󦸴ԉȺꥅ_񟵭';
+    const EXPECTED_UTF8_BASE64 = "7Jqk6aC2yaBf8Z2diVTxtoW28J6cqzfug6Ppg6PSpuOSou6Usywi6Y+k2oHls6Hon4XNhuu8kPGtq5/YkNST5aSW86a4tNSJyLrqpYVf8Z+1rQ==";
+    test("encode and decode ascii", () => {
+        const encodedAscii = encodeAsciiToBase64(EXPECTED_ASCII);
+        const decodedAscii = decodeBase64ToAscii(EXPECTED_ASCII_BASE64);
+        // encoding/decoding ascii with utf8 should be the same as ascii
+        const encodedUtf8 = encodeUtf8ToBase64(EXPECTED_ASCII);
+        const decodedUtf8 = decodeBase64ToUtf8(EXPECTED_ASCII_BASE64);
+        expect(encodedAscii).toEqual(EXPECTED_ASCII_BASE64);
+        expect(decodedAscii).toEqual(EXPECTED_ASCII);
+        expect(encodedUtf8).toEqual(EXPECTED_ASCII_BASE64);
+        expect(decodedUtf8).toEqual(EXPECTED_ASCII);
+        expect(encodedUtf8).toEqual(encodedAscii);
+        expect(decodedUtf8).toEqual(decodedAscii);
+    });
+    test("encode and decode utf8", () => {
+        const encodedUtf8 = encodeUtf8ToBase64(EXPECTED_UTF8);
+        const decodedUtf8 = decodeBase64ToUtf8(EXPECTED_UTF8_BASE64);
+        expect(encodedUtf8).toEqual(EXPECTED_UTF8_BASE64);
+        expect(decodedUtf8).toEqual(EXPECTED_UTF8);
+    });
+    test("decode utf8 compressed", () => {
+        const originalBody = { message: EXPECTED_UTF8 };
+        const body = JSON.stringify(originalBody);
+        const rawBuffer = Buffer.from(body, "utf8");
+        const compressed = compressBuffer(rawBuffer);
+        const compressedBase64 = compressed.toString("base64");
+        const uncompressedBody = decodeBase64ToUtf8(compressedBase64, true);
+        const restoredBody = JSON.parse(uncompressedBody);
+        expect(originalBody).toEqual(restoredBody);
+    });
+});
+//# sourceMappingURL=base64.test.js.map

package/dist/__test__/utils/date-utils.test.d.ts

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

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

@@ -0,0 +1,32 @@
+import { parseISO } from "date-fns";
+import { describe, expect, test } from "vitest";
+import * as CommonDateUtils from "../../utils/date-utils.js";
+const ISO = "2022-01-02T01:02:03.004Z";
+describe("CommonDateUtilsTest", () => {
+    test("dateFromIsoString", () => {
+        const parsed = CommonDateUtils.dateFromIsoString(ISO);
+        expect(parsed.toISOString()).toEqual(ISO);
+    });
+    test("dateFromIsoString fails", () => {
+        expect(() => CommonDateUtils.dateFromIsoString(`${ISO}foobar`)).toThrow();
+    });
+    test("countDiffMs", () => {
+        const start = new Date();
+        const end = new Date(start.getTime() + 1234);
+        expect(CommonDateUtils.countDiffMs(start, end)).toEqual(1234);
+    });
+    test("countDiffMs", () => {
+        const start = new Date();
+        const end = new Date(start.getTime() + 1234 * 1000);
+        expect(CommonDateUtils.countDiffInSeconds(start, end)).toEqual(1234);
+    });
+    test("dateToUTCString - preserves UTC from parsed string", () => {
+        const date = parseISO("2023-01-01T00:00Z");
+        expect(CommonDateUtils.dateToUTCString(date, CommonDateUtils.MYSQL_DATETIME_FORMAT)).toEqual("2023-01-01 00:00");
+    });
+    test("dateToUTCString - +02:00 to UTC from parsed string", () => {
+        const date = parseISO("2023-01-01T00:00+02:00");
+        expect(CommonDateUtils.dateToUTCString(date, CommonDateUtils.MYSQL_DATETIME_FORMAT)).toEqual("2022-12-31 22:00");
+    });
+});
+//# sourceMappingURL=date-utils.test.js.map

package/dist/__test__/utils/geometry.test.d.ts

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

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

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "vitest";
+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;
+const KUOPIO_WGS84_Y = 62.892983;
+const TAMPERE_KUOPIO_DISTANCE_KM = 255.8;
+describe("CommonGeometryTest", () => {
+    test("distanceBetweenWGS84PointsInKm", () => {
+        Asserter.assertToBeCloseTo(Geometry.distanceBetweenPositionsInKm([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]), TAMPERE_KUOPIO_DISTANCE_KM, 0.5);
+        console.info(Geometry.distanceBetweenPositionsInKm([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]));
+    });
+    test("distanceBetweenWGS84PointsInKm", () => {
+        Asserter.assertToBeCloseTo(Geometry.distanceBetweenPositionsInM([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]), TAMPERE_KUOPIO_DISTANCE_KM * 1000, 500);
+        console.info(Geometry.distanceBetweenPositionsInM([TAMPERE_WGS84_X, TAMPERE_WGS84_Y], [KUOPIO_WGS84_X, KUOPIO_WGS84_Y]));
+    });
+    test("areDistinctPositions", () => {
+        expect(Geometry.areDistinctPositions([1, 2], [1, 2])).toBe(false);
+        expect(Geometry.areDistinctPositions([1.1, 2.2], [1.1, 2.2])).toBe(false);
+        expect(Geometry.areDistinctPositions([1, 2.1], [1, 2])).toBe(true);
+        expect(Geometry.areDistinctPositions([1, 2], [1, 2.000000000000001])).toBe(true);
+    });
+});
+//# sourceMappingURL=geometry.test.js.map

package/dist/__test__/utils/lambda-proxy-event.test.d.ts

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

package/dist/__test__/utils/lambda-proxy-event.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "vitest";
+import { parseQueryParams } from "../../utils/lambda-proxy-event.js";
+describe("lambda-proxy-event.test", () => {
+    test("StopWatch start-stop", async () => {
+        const event = {
+            body: null,
+            headers: {},
+            multiValueHeaders: {},
+            httpMethod: "GET",
+            isBase64Encoded: false,
+            multiValueQueryStringParameters: {
+                evseStatus: ["CHARGING", "OUTOFORDER"],
+                operatorPartyId: ["LDL"],
+            },
+            queryStringParameters: {
+                evseStatus: "OUTOFORDER",
+                operatorPartyId: "LDL",
+            },
+        };
+        const parsed = parseQueryParams(event, ["evseStatus"]);
+        expect(parsed.evseStatus).toEqual(["CHARGING", "OUTOFORDER"]);
+        expect(parsed.operatorPartyId).toEqual("LDL");
+    });
+    test("StopWatch start-stop", async () => {
+        const event = {
+            body: null,
+            headers: {},
+            multiValueHeaders: {},
+            httpMethod: "GET",
+            isBase64Encoded: false,
+            multiValueQueryStringParameters: {
+                evseStatus: ["CHARGING", "OUTOFORDER"],
+                operatorPartyId: ["LDL"],
+            },
+            queryStringParameters: {
+                evseStatus: "OUTOFORDER",
+                operatorPartyId: "LDL",
+            },
+        };
+        const parsed = parseQueryParams(event, ["evseStatus"]);
+        expect(parsed.evseStatus).toEqual(["CHARGING", "OUTOFORDER"]);
+        expect(parsed.operatorPartyId).toEqual("LDL");
+    });
+});
+//# sourceMappingURL=lambda-proxy-event.test.js.map

package/dist/__test__/utils/logging.test.d.ts

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