@digitraffic/common 2026.2.5-2 → 2026.2.5-4

package/dist/__test__/imports.test.js

@@ -7,10 +7,6 @@ test("database import ok?", () => {
     const database = import("../database/database.js");
     return expect(database).resolves.toBeDefined();
 });
-test("cached import ok?", () => {
-    const cached = import("../database/cached.js");
-    return expect(cached).resolves.toBeDefined();
-});
 test("models import ok?", () => {
     const models = import("../database/models.js");
     return expect(models).resolves.toBeDefined();
@@ -243,8 +239,8 @@ test("canaryKeys import ok?", () => {
     const canaryKeys = import("../aws/infra/canaries/canary-keys.js");
     return expect(canaryKeys).resolves.toBeDefined();
 });
-test("proxytypes import ok?", () => {
-    const proxytypes = import("../aws/types/proxytypes.js");
+test("lambda-proxy-types import ok?", () => {
+    const proxytypes = import("../aws/types/lambda-proxy-types.js");
     return expect(proxytypes).resolves.toBeDefined();
 });
 test("tags import ok?", () => {

package/dist/__test__/infra/api/integration.test.js

@@ -58,7 +58,7 @@ describe("integration tests", () => {
         const app = new App();
         const stack = new Stack(app);
         const f = new LambdaFunction(stack, "id", {
-            runtime: Runtime.NODEJS_22_X,
+            runtime: Runtime.NODEJS_24_X,
             code: Code.fromInline("placeholder"),
             handler: "handler",
         });

package/dist/__test__/infra/api/response.test.js

@@ -1,8 +1,6 @@
 import etag from "etag";
 import velocity from "velocityjs";
 import { RESPONSE_DEFAULT_LAMBDA } from "../../../aws/infra/api/response.js";
-import { compressBuffer, decodeBase64ToString, } from "../../../aws/types/lambda-response.js";
-import { TEST_BIG_JSON } from "../../types/lambda-response.test.js";
 const TEST_BODY = "Hello world!";
 describe("response tests", () => {
     function generateEtagValueFromString(body) {
@@ -11,24 +9,20 @@ describe("response tests", () => {
     function generateEtagValueFromBase64String(bodyBase64) {
         return etag(bodyBase64);
     }
-    function generateResponse(status, fileName, timestamp, compressBody = false, body = TEST_BODY) {
+    function generateResponse(status, fileName, timestamp) {
         const compile = new velocity.Compile(velocity.parse(RESPONSE_DEFAULT_LAMBDA));
-        const rawBuffer = Buffer.from(body, "utf8");
         const output = compile.render({
             input: {
                 path: () => ({
-                    body: (compressBody
-                        ? compressBuffer(rawBuffer)
-                        : rawBuffer).toString("base64"),
+                    body: Buffer.from(TEST_BODY).toString("base64"),
                     status,
                     fileName,
                     timestamp: timestamp?.toUTCString(),
-                    etag: generateEtagValueFromString(body),
-                    compressed: compressBody,
+                    etag: generateEtagValueFromString(TEST_BODY),
                 }),
             },
             util: {
-                base64Decode: (data) => decodeBase64ToString(data, compressBody),
+                base64Decode: (data) => Buffer.from(data, "base64").toString(),
             },
             context: {
                 responseOverride: {
@@ -39,7 +33,6 @@ describe("response tests", () => {
                         ETag: undefined,
                         "Last-Modified": undefined,
                         "Content-Disposition": undefined,
-                        "Content-Encoding": undefined,
                     },
                 },
             },
@@ -47,8 +40,8 @@ describe("response tests", () => {
         // @ts-expect-error: context is not in the type definition
         return [output, compile.context.context];
     }
-    function assertOutputAndContext(output, context, status, contentType, fileName, timestamp, body = TEST_BODY, compressBody = false) {
-        expect(output).toEqual(body);
+    function assertOutputAndContext(output, context, status, contentType, fileName, timestamp) {
+        expect(output).toEqual(TEST_BODY);
         expect(context).toMatchObject({
             responseOverride: {
                 status,
@@ -57,8 +50,7 @@ describe("response tests", () => {
                     "Access-Control-Allow-Origin": "*",
                     "Content-Disposition": fileName,
                     "Last-Modified": timestamp?.toUTCString(),
-                    ETag: generateEtagValueFromString(body),
-                    "Content-Encoding": compressBody ? "gzip" : undefined,
+                    ETag: generateEtagValueFromString(TEST_BODY),
                 },
             },
         });
@@ -80,11 +72,5 @@ describe("response tests", () => {
         const [output, context] = generateResponse(204);
         assertOutputAndContext(output, context, 204, "text/plain");
     });
-    test("test 200 - compressed", () => {
-        const now = new Date();
-        const body = JSON.stringify(TEST_BIG_JSON);
-        const [output, context] = generateResponse(200, "test.json", now, true, body);
-        assertOutputAndContext(output, context, undefined, undefined, 'attachment; filename="test.json"', now, body, true);
-    });
 });
 //# sourceMappingURL=response.test.js.map

package/dist/__test__/stack/dt-function.test.js

@@ -8,8 +8,10 @@ import { EnvKeys } from "../../aws/runtime/environment.js";
 import { TrafficType } from "../../types/traffictype.js";
 const TEST_ENV_VAR = "TEST_ENV_VAR";
 const TEST_ENV_VALUE = "testValue";
+// AWS::Lambda::Function Template Reference
+// https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html
 describe("FunctionBuilder test", () => {
-    function createTemplate(tester, plain = false) {
+    function createTemplate(tester, plain = false, lambdaName = "test") {
         const app = new App();
         const stack = new DigitrafficStack(app, "test-stack", {
             alarmTopicArn: "",
@@ -24,10 +26,10 @@ describe("FunctionBuilder test", () => {
             [TEST_ENV_VAR]: TEST_ENV_VALUE,
         };
         const builder = plain
-            ? FunctionBuilder.plain(stack, "test")
+            ? FunctionBuilder.plain(stack, lambdaName)
                 .withEnvironment(environment)
                 .withCode(Code.fromInline("{}"))
-            : FunctionBuilder.create(stack, "test")
+            : FunctionBuilder.create(stack, lambdaName)
                 .withoutDatabaseAccess()
                 .withEnvironment(environment)
                 .withCode(Code.fromInline("{}"));
@@ -62,7 +64,7 @@ describe("FunctionBuilder test", () => {
                     [TEST_ENV_VAR]: TEST_ENV_VALUE,
                 },
             },
-            Runtime: Runtime.NODEJS_22_X.name,
+            Runtime: Runtime.NODEJS_24_X.name,
             MemorySize: 128,
             Timeout: 60,
             Handler: "test.handler",
@@ -81,10 +83,18 @@ describe("FunctionBuilder test", () => {
     });
     test("Lambda runtime is set", () => {
         const template = createTemplate((builder) => {
-            builder.withRuntime(Runtime.NODEJS_20_X);
+            builder.withRuntime(Runtime.NODEJS_24_X);
         });
         template.hasResourceProperties("AWS::Lambda::Function", {
-            Runtime: Runtime.NODEJS_20_X.name,
+            Runtime: Runtime.NODEJS_24_X.name,
+        });
+    });
+    test("Lambda description is set", () => {
+        const template = createTemplate((builder) => {
+            builder.withDescription("Does something useful");
+        });
+        template.hasResourceProperties("AWS::Lambda::Function", {
+            Description: "Does something useful",
         });
     });
     test("Lambda memory size is set", () => {
@@ -127,6 +137,20 @@ describe("FunctionBuilder test", () => {
             Handler: "custom.main",
         });
     });
+    test("Lambda handler module is resolved from path last element", () => {
+        const template = createTemplate((_builder) => { }, false, "api/charging-network/v1/operators");
+        // const lambdas = template.findResources("AWS::Lambda::Function");
+        // console.debug(JSON.stringify(lambdas, null, 2));
+        template.hasResourceProperties("AWS::Lambda::Function", {
+            Handler: "operators.handler",
+        });
+    });
+    test("Lambda handler module is same as lambda name", () => {
+        const template = createTemplate((_builder) => { }, false, "operators");
+        template.hasResourceProperties("AWS::Lambda::Function", {
+            Handler: "operators.handler",
+        });
+    });
     test("withRolePolicies adds custom policy to lambda role", () => {
         const template = createTemplate((builder) => {
             builder.withRolePolicies(new PolicyStatement({

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,154 @@
+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,80 @@
+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

@@ -1,8 +1,9 @@
-export declare const TEST_BIG_JSON: {
-    items: {
-        id: number;
-        name: string;
-        description: string;
-        value: number;
-    }[];
+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

@@ -1,32 +1,24 @@
-import { decodeBase64ToString, LambdaResponse, LambdaResponseBuilder, } from "../../aws/types/lambda-response.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(),
-    })),
+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", () => {
-    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 assertJson(response, expectedJson, expectedStatus, expectedFilename, expectedTimestamp) {
-        const body = JSON.parse(decodeBase64ToString(response.body, response.compressed));
+        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 = decodeBase64ToString(response.body, response.compressed);
+        const body = decodeBase64ToUtf8(response.body);
         expect(body).toEqual(expectedString);
         expect(response.status).toEqual(expectedStatus);
         expect(response.fileName).toEqual(expectedFilename);
@@ -54,15 +46,15 @@ describe("lambda-response", () => {
     });
     test("notFound", () => {
         const response = LambdaResponse.notFound();
-        assertBinary(response, "Not found", 404);
+        assertBinary(response, "Not Found", 404);
     });
     test("internalError", () => {
         const response = LambdaResponse.internalError();
-        assertBinary(response, "Internal error", 500);
+        assertBinary(response, "Internal Error", 500);
     });
     test("notImplemented", () => {
         const response = LambdaResponse.notImplemented();
-        assertBinary(response, "Not implemented", 501);
+        assertBinary(response, "Not Implemented", 501);
     });
     // Builder
     test("Builder - okJson - without fileName", () => {
@@ -76,47 +68,5 @@ describe("lambda-response", () => {
             .build();
         assertJson(response, TEST_JSON, 200, TEST_FILENAME);
     });
-    test("Builder - okJson - with fileName and timestamp", () => {
-        const response = LambdaResponseBuilder.create()
-            .withBody(TEST_JSON)
-            .withFileName(TEST_FILENAME)
-            .withTimestamp(TEST_TIMESTAMP)
-            .build();
-        const response2 = LambdaResponseBuilder.create()
-            .withBody(TEST_JSON)
-            .withFileName(TEST_FILENAME)
-            .withTimestamp(TEST_TIMESTAMP_STR)
-            .build();
-        assertJson(response, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
-        assertJson(response2, TEST_JSON, 200, TEST_FILENAME, TEST_TIMESTAMP);
-    });
-    test("Builder - 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("Builder - compression uneffective for small json", () => {
-        const response = LambdaResponseBuilder.create()
-            .withBody(TEST_JSON)
-            .withFileName(TEST_FILENAME)
-            .withCompression()
-            .withDebug()
-            .build();
-        expect(response.compressed).toBe(false);
-        assertJson(response, TEST_JSON, 200, TEST_FILENAME);
-    });
-    test("Builder - compression effective for large json", () => {
-        const response = LambdaResponseBuilder.create()
-            .withBody(TEST_BIG_JSON)
-            .withFileName(TEST_FILENAME)
-            .withCompression()
-            .withDebug()
-            .build();
-        expect(response.compressed).toBe(true);
-        assertJson(response, TEST_BIG_JSON, 200, TEST_FILENAME);
-    });
 });
 //# sourceMappingURL=lambda-response.test.js.map

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

@@ -1,4 +1,4 @@
-import { decodeBase64ToAscii, decodeBase64ToUtf8, encodeAsciiToBase64, encodeUtf8ToBase64, } from "../../utils/base64.js";
+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";
@@ -23,5 +23,15 @@ describe("Base64UtilTest", () => {
         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/lambda-proxy-event.test.d.ts

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

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

@@ -0,0 +1,44 @@
+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.js

@@ -1,6 +1,6 @@
 import { Writable } from "node:stream";
 import { DtLogger } from "../../aws/runtime/dt-logger.js";
-import { logException } from "../../utils/logging.js";
+import { logException, truncateEnd, truncateMiddle, } from "../../utils/logging.js";
 const TEST_METHODNAME = "test.logException";
 describe("logging-test", () => {
     function assertLogError(error, expected, includeStack = false) {
@@ -58,5 +58,17 @@ describe("logging-test", () => {
             stack: true,
         }, true);
     });
+    test("truncateEnd - not truncated as would be longer", () => {
+        expect(truncateEnd("This is a test string", 10)).toBe("This is a test string");
+    });
+    test("truncateEnd", () => {
+        expect(truncateEnd("This is a test string that is long enough", 10)).toBe("This is a [TRUNCATED 31 CHARS]");
+    });
+    test("truncateMiddle - not truncated as would be longer", () => {
+        expect(truncateMiddle("This is a test string", 10)).toBe("This is a test string");
+    });
+    test("truncateMiddle", () => {
+        expect(truncateMiddle("This is a test string that is long enough", 20)).toBe("This is a [TRUNCATED 21 CHARS] ong enough");
+    });
 });
 //# sourceMappingURL=logging.test.js.map