@digitraffic/common 2024.1.24-2 → 2024.1.30-1

package/dist/__test__/runtime/dt-logger.test.mjs

@@ -0,0 +1,108 @@
+import { Writable } from "stream";
+import { DtLogger } from "../../aws/runtime/dt-logger.mjs";
+const LOG_LINE = {
+    method: "dt-logger.test",
+    message: "FOO",
+};
+describe("dt-logger", () => {
+    function assertLog(config, message, expected) {
+        assertWrite(config, (logger) => {
+            logger.info(message);
+        }, expected);
+    }
+    function assertDebug(config, message, expected) {
+        assertWrite(config, (logger) => {
+            logger.debug(message);
+        }, expected);
+    }
+    function assertWrite(config, writeFunction, expected) {
+        const logged = [];
+        const writeStream = new Writable({
+            write: (chunk) => {
+                logged.push(chunk.toString());
+            },
+        });
+        const logger = new DtLogger({
+            ...config,
+            ...{ writeStream: writeStream },
+        });
+        writeFunction(logger);
+        expect(logged.length).toBe(1);
+        const loggedLine = JSON.parse(logged[0]);
+        console.info(loggedLine);
+        if (typeof expected === "object" &&
+            "stack" in expected &&
+            expected.stack) {
+            const stack = loggedLine['stack'];
+            delete loggedLine['stack'];
+            delete expected.stack;
+            expect(stack).toBeDefined();
+        }
+        expect(loggedLine).toMatchObject(expected);
+    }
+    test("custom values", () => {
+        const date = new Date();
+        assertLog({}, {
+            ...LOG_LINE,
+            customDate: date,
+        }, {
+            ...LOG_LINE,
+            date: date.toISOString(),
+        });
+    });
+    test("custom count should be a number", () => {
+        assertLog({}, {
+            ...LOG_LINE,
+            customFooCount: 123,
+        }, {
+            ...LOG_LINE,
+            fooCount: 123,
+        });
+    });
+    test("default values", () => {
+        assertLog({}, LOG_LINE, {
+            method: LOG_LINE.method,
+            message: LOG_LINE.message,
+            level: "INFO",
+        });
+    });
+    test("set lambdaName", () => {
+        const LAMBDA_NAME = "test_lambda_name";
+        assertLog({ lambdaName: LAMBDA_NAME }, LOG_LINE, {
+            lambdaName: LAMBDA_NAME,
+            method: LOG_LINE.method,
+            message: LOG_LINE.message,
+            level: "INFO",
+        });
+    });
+    test("set runtime", () => {
+        const RUNTIME = "test_runtime";
+        assertLog({ runTime: RUNTIME }, LOG_LINE, {
+            message: LOG_LINE.message,
+            method: LOG_LINE.method,
+            level: "INFO",
+            runtime: RUNTIME,
+        });
+    });
+    test("debug - string", () => {
+        const DEBUG_STRING = "debug string";
+        assertDebug({}, DEBUG_STRING, {
+            message: DEBUG_STRING,
+            level: "DEBUG",
+        });
+    });
+    test("debug - json", () => {
+        const DEBUG_JSON = {
+            debug: "debug",
+            thing: 42,
+        };
+        assertDebug({}, DEBUG_JSON, {
+            message: {
+                debug: "debug",
+                thing: 42,
+            },
+            level: "DEBUG",
+        });
+    });
+});
+//# sourceMappingURL=dt-logger.test.mjs.map

package/dist/__test__/secrets/secret-holder.test.d.mts

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

package/dist/__test__/secrets/secret-holder.test.mjs

@@ -0,0 +1,89 @@
+import { mockSecret, stubSecretsManager } from "../../test/secrets-manager.mjs";
+import sinon from "sinon";
+const SECRET_WITH_PREFIX = {
+    "prefix.value": "value",
+    "prefix.name": "name",
+    "wrong.value": "value",
+    username: "DB_USER",
+};
+const SECRET_EMPTY = {};
+const stubSM = stubSecretsManager();
+const secretHolder = await import("../../aws/runtime/secrets/secret-holder.mjs");
+const database = await import("../../database/database.mjs");
+const { SecretHolder } = secretHolder;
+const { DatabaseEnvironmentKeys } = database;
+describe("SecretHolder - tests", () => {
+    beforeEach(() => {
+        process.env['SECRET_ID'] = "test-id";
+    });
+    afterEach(() => {
+        sinon.restore();
+        sinon.reset();
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete process.env[DatabaseEnvironmentKeys.DB_USER];
+    });
+    test("get - no secret", () => {
+        mockSecret(null);
+        const holder = SecretHolder.create();
+        const secret = holder.get();
+        return expect(secret).rejects.toThrowError("No secret found!");
+    }, 10000);
+    test("get - empty secret", () => {
+        mockSecret(SECRET_EMPTY);
+        const holder = SecretHolder.create();
+        const secret = holder.get();
+        return expect(secret).resolves.toEqual(SECRET_EMPTY);
+    });
+    test("get - no prefix", () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const holder = SecretHolder.create();
+        const secret = holder.get();
+        return expect(secret).resolves.toEqual(SECRET_WITH_PREFIX);
+    });
+    test("get - check keys - not found", () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const holder = SecretHolder.create("", ["not_found"]);
+        const secret = holder.get();
+        return expect(secret).rejects.toThrow();
+    });
+    test("get - check keys - found", () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const holder = SecretHolder.create("", ["prefix.value", "username"]);
+        return expect(holder.get()).resolves.toBeDefined();
+    });
+    test("getSecret - with prefix", () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const holder = SecretHolder.create("prefix");
+        const secret = holder.get();
+        return expect(secret).resolves.toEqual({
+            value: "value",
+            name: "name",
+        });
+    });
+    test("get - ttl - do not fetch", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const holder = SecretHolder.create();
+        const callCount = stubSM.callCount;
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 1);
+        // gets cached secret
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 1);
+    });
+    test("get - ttl - fetch", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const holder = new SecretHolder("", "", [], {
+            ttl: 1,
+        });
+        const callCount = stubSM.callCount;
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 1);
+        // cache expires, fetches secret again
+        const start = Date.now();
+        while (Date.now() < start + 2000)
+            ;
+        await holder.get();
+        expect(stubSM.callCount).toEqual(callCount + 2);
+    });
+});
+//# sourceMappingURL=secret-holder.test.mjs.map

package/dist/__test__/secrets/secret.test.d.mts

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

package/dist/__test__/secrets/secret.test.mjs

@@ -0,0 +1,42 @@
+import { mockSecret, stubSecretsManager } from "../../test/secrets-manager.mjs";
+import sinon from "sinon";
+const SECRET_ID = "test_secret";
+const SECRET_WITH_PREFIX = {
+    "prefix.value": "value",
+    "prefix.name": "name",
+    "wrong.value": "value",
+};
+const SECRET_EMPTY = {};
+stubSecretsManager();
+const secret = await import("../../aws/runtime/secrets/secret.mjs");
+const { getSecret } = secret;
+describe("secret - test", () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    test("getSecret - no secret", async () => {
+        mockSecret(null);
+        await expect(async () => {
+            await getSecret(SECRET_ID, "");
+        }).rejects.toThrowError("No secret found!");
+    });
+    test("getSecret - empty secret", async () => {
+        mockSecret(SECRET_EMPTY);
+        const secret = await getSecret(SECRET_ID, "");
+        expect(secret).toEqual(SECRET_EMPTY);
+    });
+    test("getSecret - no prefix", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const secret = await getSecret(SECRET_ID, "");
+        expect(secret).toEqual(SECRET_WITH_PREFIX);
+    });
+    test("getSecret - with prefix", async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+        const secret = await getSecret(SECRET_ID, "prefix");
+        expect(secret).toEqual({
+            value: "value",
+            name: "name",
+        });
+    });
+});
+//# sourceMappingURL=secret.test.mjs.map

package/dist/__test__/test/httpserver.test.d.mts

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

package/dist/__test__/test/httpserver.test.mjs

@@ -0,0 +1,154 @@
+import { TestHttpServer, ERROR_NO_MATCH, ERRORCODE_NOT_FOUND, } from "../../test/httpserver.mjs";
+import { IncomingMessage } from "http";
+import { Socket } from "net";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as http from "http";
+import { expect } from "@jest/globals";
+const threadLocalPort = new AsyncLocalStorage();
+const DEFAULT_PATH = "/";
+const DEFAULT_PROPS = {
+    "/": () => "",
+};
+const findOpenPort = async (excludedPorts) => {
+    const ephemeralPorts = Array.from({ length: 65535 - 1024 + 1 }, (__, i) => 1024 + i);
+    const allSocketEvents = [
+        "close",
+        "connect",
+        "data",
+        "drain",
+        "end",
+        "error",
+        "lookup",
+        "ready",
+        "timeout",
+    ];
+    let openPort = null;
+    for (const testPort of ephemeralPorts) {
+        if (openPort !== null) {
+            break;
+        }
+        if (excludedPorts.has(testPort)) {
+            continue;
+        }
+        const portConnected = new Promise((resolve) => {
+            const socket = new Socket();
+            socket.setTimeout(500);
+            for (const socketEvent of allSocketEvents) {
+                if (socketEvent === "error") {
+                    socket.on(socketEvent, (error) => {
+                        socket.destroy();
+                        if (error.code === "ECONNREFUSED") {
+                            resolve(testPort);
+                        }
+                        else {
+                            resolve(null);
+                        }
+                    });
+                }
+                else {
+                    socket.on(socketEvent, () => {
+                        socket.destroy();
+                        resolve(null);
+                    });
+                }
+            }
+            // connect method is asynchronous. That is why we wrap this thing inside of a promise.
+            socket.connect({ port: testPort, host: "127.0.0.1" });
+        });
+        openPort = await portConnected;
+    }
+    if (openPort === null) {
+        throw Error("All ephemeral ports in use!");
+    }
+    return openPort;
+};
+const usedPorts = new Set();
+async function withServer(fn, props = DEFAULT_PROPS, statusCode = 200) {
+    const server = new TestHttpServer();
+    let openPort;
+    while (!openPort) {
+        const foundPort = await findOpenPort(usedPorts);
+        console.info(`foundPort ${foundPort}`);
+        if (!usedPorts.has(foundPort)) {
+            usedPorts.add(foundPort);
+            openPort = foundPort;
+        }
+    }
+    console.info(`Using port ${openPort} to run the test`);
+    server.listen(openPort, props, false, statusCode);
+    threadLocalPort.enterWith(openPort);
+    try {
+        await fn(server);
+    }
+    finally {
+        await server.close();
+        console.info("Server closed");
+    }
+}
+function sendGetRequest(path = DEFAULT_PATH) {
+    return sendRequest("GET", path);
+}
+function sendPostRequest(path = DEFAULT_PATH, body) {
+    return sendRequest("POST", path, body);
+}
+function sendRequest(method, path, body) {
+    return new Promise((resolve, reject) => {
+        const port = threadLocalPort.getStore();
+        const request = http.request({
+            path,
+            port,
+            method,
+        }, (response) => {
+            response.on("data", () => {
+                // do nothing
+            });
+            //the whole response has been received, so we just print it out here
+            response.on("end", () => {
+                resolve(response);
+            });
+            response.on("error", (error) => {
+                reject(error);
+            });
+        });
+        if (method === "POST") {
+            request.write(body);
+        }
+        request.end();
+    });
+}
+test("no calls", () => {
+    return withServer((server) => {
+        expect(server.getCallCount()).toEqual(0);
+    });
+});
+test("one get", async () => {
+    await withServer(async (server) => {
+        await sendGetRequest();
+        expect(server.getCallCount()).toEqual(1);
+    });
+});
+test("one get - no MATCH", async () => {
+    await withServer(async (server) => {
+        const response = await sendGetRequest("/no-match");
+        expect(server.getCallCount()).toEqual(1);
+        expect(server.getRequestBody(0)).toEqual(ERROR_NO_MATCH);
+        expect(response.statusCode).toEqual(ERRORCODE_NOT_FOUND);
+    });
+});
+test("get - error 405", async () => {
+    const ERROR_CODE = 405;
+    await withServer(async (server) => {
+        const response = await sendGetRequest();
+        expect(server.getCallCount()).toEqual(1);
+        expect(response.statusCode).toEqual(ERROR_CODE);
+    }, DEFAULT_PROPS, ERROR_CODE);
+});
+test("one post", async () => {
+    await withServer(async (server) => {
+        const testBody = "Testing123!";
+        await sendPostRequest(DEFAULT_PATH, testBody);
+        expect(server.getCallCount()).toEqual(1);
+        expect(server.getRequestBody(0)).toEqual(testBody);
+    });
+});
+//# sourceMappingURL=httpserver.test.mjs.map

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

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

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

@@ -0,0 +1,58 @@
+import { LambdaResponse } from "../../aws/types/lambda-response.mjs";
+describe("lambda-response", () => {
+    const TEST_MESSAGE = "HELLO";
+    const TEST_COUNT = 12;
+    const TEST_FILENAME = "file.txt";
+    const TEST_TIMESTAMP = new Date();
+    const TEST_JSON = {
+        message: TEST_MESSAGE,
+        count: TEST_COUNT,
+    };
+    function assertJson(response, expectedJson, expectedStatus, expectedFilename, expectedTimestamp) {
+        const body = JSON.parse(Buffer.from(response.body, "base64").toString());
+        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 = Buffer.from(response.body, "base64").toString();
+        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);
+    });
+});
+//# sourceMappingURL=lambda-response.test.mjs.map

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

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

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

@@ -0,0 +1,27 @@
+import { parseISO } from "date-fns";
+import * as CommonDateUtils from "../../utils/date-utils.mjs";
+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")).toThrowError();
+    });
+    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("dateFromIsoString", () => {
+        const date = parseISO("2023-01-01T00:00Z");
+        expect(CommonDateUtils.dateToUTCString(date, CommonDateUtils.MYSQL_DATETIME_FORMAT)).toEqual("2023-01-01 00:00");
+    });
+});
+//# sourceMappingURL=date-utils.test.mjs.map

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

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

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

@@ -0,0 +1,24 @@
+import { Asserter } from "../../test/asserter.mjs";
+import * as Geometry from "../../utils/geometry.mjs";
+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.mjs.map

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

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

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

@@ -0,0 +1,78 @@
+import { AxiosError } from "axios";
+import { Writable } from "stream";
+import { DtLogger } from "../../aws/runtime/dt-logger.mjs";
+import { logException } from "../../utils/logging.mjs";
+const TEST_METHODNAME = "test.logException";
+describe("dt-logger", () => {
+    function assertLogError(error, expected, includeStack = false) {
+        assertWrite((logger) => {
+            logException(logger, error, includeStack);
+        }, expected);
+    }
+    function assertAxiosError(error, expected) {
+        assertWrite((logger) => {
+            logException(logger, error);
+        }, expected);
+    }
+    function assertWrite(writeFunction, expected) {
+        const logged = [];
+        const writeStream = new Writable({
+            write: (chunk) => {
+                logged.push(chunk.toString());
+            },
+        });
+        const logger = new DtLogger({
+            ...{ writeStream: writeStream },
+        });
+        writeFunction(logger);
+        expect(logged.length).toBe(1);
+        const loggedLine = JSON.parse(logged[0]);
+        console.info(loggedLine);
+        if (expected.stack) {
+            const stack = loggedLine.stack;
+            delete loggedLine.stack;
+            delete expected.stack;
+            expect(stack).toBeDefined();
+        }
+        expect(loggedLine).toEqual(expected);
+    }
+    test("log error - string", () => {
+        const STRING_ERROR = "string error";
+        assertLogError(STRING_ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: STRING_ERROR,
+            level: "ERROR",
+        });
+    });
+    test("log error - error", () => {
+        const ERROR = new Error("Errormessage");
+        assertLogError(ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: ERROR.message,
+            level: "ERROR",
+        });
+    });
+    test("log error - error with stack", () => {
+        const ERROR = new Error("Errormessage");
+        assertLogError(ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: ERROR.message,
+            level: "ERROR",
+            stack: true,
+        }, true);
+    });
+    test("log error - AxiosError", () => {
+        const ERROR = new AxiosError("ErrorFromAxios", "12");
+        assertAxiosError(ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: ERROR.message,
+            level: "ERROR",
+            code: ERROR.code,
+        });
+    });
+});
+//# sourceMappingURL=logging.test.mjs.map

package/dist/__test__/utils/utils.test.d.mts

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

package/dist/__test__/utils/utils.test.mjs

@@ -0,0 +1,43 @@
+import * as ArrayUtils from "../../utils/utils.mjs";
+describe("ArrayUtils", () => {
+    test("bothArraysHasSameValues", () => {
+        expect(ArrayUtils.bothArraysHasSameValues([], [])).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], ["a"])).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], ["a", "a"])).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(["a", "a"], ["a", "a"])).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(null, null)).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(undefined, undefined)).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(null, undefined)).toEqual(true);
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], undefined)).toEqual(false);
+        expect(ArrayUtils.bothArraysHasSameValues(["a"], null)).toEqual(false);
+        /* eslint-enable */
+        expect(ArrayUtils.bothArraysHasSameValues(["a", "b"], ["a", "a"])).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
+        expect(ArrayUtils.bothArraysHasSameValues([o1], [o1])).toEqual(true);
+        // Object's are not the same but the contents are the same
+        expect(ArrayUtils.bothArraysHasSameValues([o1], [o2])).toEqual(false);
+    });
+    test("getFirst - empty throws", () => {
+        expect(() => {
+            ArrayUtils.getFirst([]);
+        }).toThrow();
+    });
+    test("getFirst - two objects", () => {
+        expect(ArrayUtils.getFirst([1, 2])).toEqual(1);
+    });
+    test("getFirst - two objects with sort function", () => {
+        expect(ArrayUtils.getFirst([1, 2], (a) => -a)).toEqual(2);
+    });
+    test("getLast - empty throws", () => {
+        expect(() => {
+            ArrayUtils.getLast([]);
+        }).toThrow();
+    });
+    test("getLast - two objects", () => {
+        expect(ArrayUtils.getLast([1, 2])).toEqual(2);
+    });
+});
+//# sourceMappingURL=utils.test.mjs.map

package/dist/aws/infra/api/handler-factory.mjs

@@ -1,4 +1,6 @@
 import { getEnvVariableOrElse } from "../../../utils/utils.mjs";
+import { DtLogger } from "../../runtime/dt-logger.mjs";
+import { LambdaResponse } from "../../types/lambda-response.mjs";
 const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
@@ -10,6 +12,8 @@ const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
  * creating handler-functions for your lambdas.
  */
 export class HandlerFactory {
+    loggingHandler;
+    errorHandler;
     constructor() {
         this.loggingHandler = async (method) => {
             const start = Date.now();