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

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

@@ -0,0 +1,75 @@
+import { Writable } from "node:stream";
+import { describe, expect, test } from "vitest";
+import { DtLogger } from "../../aws/runtime/dt-logger.js";
+import { logException, truncateEnd, truncateMiddle, } from "../../utils/logging.js";
+const TEST_METHODNAME = "test.logException";
+describe("logging-test", () => {
+    function assertLogError(error, expected, includeStack = false) {
+        assertWrite((logger) => {
+            logException(logger, error, includeStack);
+        }, 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).toMatchObject(expected);
+    }
+    test("log error - string", () => {
+        const STRING_ERROR = "string error";
+        assertLogError(STRING_ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: `${TEST_METHODNAME} error=${STRING_ERROR} type=Error`,
+            level: "ERROR",
+        });
+    });
+    test("log error - error", () => {
+        const ERROR = new Error("Errormessage");
+        assertLogError(ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: `${TEST_METHODNAME} error=${ERROR.message} type=Error`,
+            level: "ERROR",
+        });
+    });
+    test("log error - error with stack", () => {
+        const ERROR = new Error("Errormessage");
+        assertLogError(ERROR, {
+            type: "Error",
+            method: TEST_METHODNAME,
+            message: `${TEST_METHODNAME} error=${ERROR.message} type=Error`,
+            level: "ERROR",
+            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

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 { describe, expect, test } from "vitest";
+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.d.ts

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

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

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "vitest";
+import * as ArrayUtils from "../../utils/utils.js";
+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);
+        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);
+    });
+    test("isDefined", () => {
+        expect([1, 2, undefined, null, 3].filter(ArrayUtils.isDefined)).toEqual([
+            1, 2, 3,
+        ]);
+    });
+});
+//# sourceMappingURL=utils.test.js.map

package/dist/aws/infra/acl-builder.d.ts

@@ -0,0 +1,53 @@
+import { CfnWebACL } from "aws-cdk-lib/aws-wafv2";
+import type { Construct } from "constructs";
+export type AWSManagedWafRule = "CommonRuleSet" | "AmazonIpReputationList" | "KnownBadInputsRuleSet" | "SQLiRuleSet";
+export type ExcludedAWSRules = {
+    [key in AWSManagedWafRule]?: string[];
+};
+export type CfnWebAclRuleProperty = {
+    [P in keyof CfnWebACL.RuleProperty as Exclude<P, "priority">]: CfnWebACL.RuleProperty[P];
+};
+/**
+ * Builder class for building CfnWebACL.
+ *
+ * Currently supports:
+ * * Some AWS managed WAF rules
+ * * IP blacklisting/whitelisting
+ */
+export declare class AclBuilder {
+    readonly _construct: Construct;
+    readonly _countRules: CfnWebAclRuleProperty[];
+    readonly _blockRules: CfnWebAclRuleProperty[];
+    readonly _name: string;
+    _scope: string;
+    _customResponseBodies: Record<string, CfnWebACL.CustomResponseBodyProperty>;
+    constructor(construct: Construct, name?: string);
+    isRuleDefined(rules: AWSManagedWafRule[] | "all", rule: AWSManagedWafRule): boolean;
+    withAWSManagedRules(rules?: AWSManagedWafRule[] | "all", excludedRules?: ExcludedAWSRules): this;
+    /**
+     * Block access from given addresses
+     */
+    withIpBlacklistRule(addresses: string[]): this;
+    /**
+     * Allow access only from the given addresses
+     */
+    withIpWhitelistRule(addresses: string[]): this;
+    withThrottleRule(name: string, limit: number, isHeaderRequired: boolean, isBasedOnIpAndUriPath: boolean, customResponseBodyKey?: string, path?: RegExp): this;
+    withCustomResponseBody(key: string, customResponseBody: CfnWebACL.CustomResponseBodyProperty): this;
+    withThrottleDigitrafficUserIp(limit: number | undefined): this;
+    withThrottleDigitrafficUserIpAndUriPath(limit: number | undefined): this;
+    withThrottleAnonymousUserIp(limit: number | undefined): AclBuilder;
+    withThrottleAnonymousUserIpByUriPath(limit: number | undefined, path: RegExp | undefined): AclBuilder;
+    withThrottleAnonymousUserIpAndUriPath(limit: number | undefined): this;
+    withCountDigitrafficUserIp(limit: number | undefined): this;
+    withCountDigitrafficUserIpAndUriPath(limit: number | undefined): this;
+    withCountAnonymousUserIp(limit: number | undefined): this;
+    withCountAnonymousUserIpAndUriPath(limit: number | undefined): this;
+    /**
+     * Block requests with a query string larger than the specified size.
+     */
+    withQueryStringSizeRestriction(limit: number): this;
+    _isCustomResponseBodyKeySet(key: string): boolean;
+    _addThrottleResponseBody(customResponseBodyKey: string, limit: number): void;
+    build(): CfnWebACL;
+}