Add cross-runtime test suite for node, browser, deno, bun, and workers

- 66 new vitest tests covering sub-loggers, masking, errors, exotic types,
  hidden mode, concurrency, and simulated worker/edge/deno/bun environments
- 10 new playwright browser tests for json, masking, sub-loggers, transports
- deno test adapter with 12 tests importing from dist/esm
- add test:bun and test:deno npm scripts
- add bun and deno CI jobs

Author: terehov

.github/workflows/ci.yml

@@ -35,3 +35,33 @@ jobs:
               run: npm run test:browser
             - name: Report coverage
               uses: codecov/codecov-action@v3
+
+    test-bun:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 20.x
+            - uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: latest
+            - run: npm ci
+            - name: Run tests with Bun
+              run: npm run test:bun
+
+    test-deno:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 20.x
+            - uses: denoland/setup-deno@v2
+              with:
+                  deno-version: v2.x
+            - run: npm ci
+            - name: Build for Deno
+              run: npm run build
+            - name: Run Deno tests
+              run: deno test --allow-read --allow-env tests/deno_runner.ts

package.json

@@ -43,6 +43,8 @@
     "format": "prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\"",
     "test": "vitest run",
     "test:browser": "npx playwright test",
+    "test:bun": "bunx vitest run",
+    "test:deno": "npm run build && deno test --allow-read --allow-env tests/deno_runner.ts",
     "test:all": "vitest run && npx playwright test",
     "test-puppeteer-serve": "npm run build-browser && node tests/support/browser/server/index.cjs -p 4444",
     "coverage": "vitest run --coverage",

tests/25_deep_subloggers.test.ts

@@ -0,0 +1,95 @@
+import { Logger } from "../src/index.js";
+
+describe("Deep sub-loggers", () => {
+  test("5-level chain preserves all parentNames", () => {
+    const l1 = new Logger({ type: "hidden", name: "root" });
+    const l2 = l1.getSubLogger({ name: "child1" });
+    const l3 = l2.getSubLogger({ name: "child2" });
+    const l4 = l3.getSubLogger({ name: "child3" });
+    const l5 = l4.getSubLogger({ name: "child4" });
+
+    const logObj = l5.info("deep log");
+    const meta = logObj?._meta;
+
+    expect(meta?.name).toBe("child4");
+    expect(meta?.parentNames).toEqual(["root", "child1", "child2", "child3"]);
+  });
+
+  test("deep chain accumulates prefixes from all ancestors", () => {
+    const l1 = new Logger({ type: "hidden", prefix: ["[P1]"] });
+    const l2 = l1.getSubLogger({ prefix: ["[P2]"] });
+    const l3 = l2.getSubLogger({ prefix: ["[P3]"] });
+    const l4 = l3.getSubLogger({ prefix: ["[P4]"] });
+
+    const logObj = l4.info("msg");
+
+    expect(logObj?.["0"]).toBe("[P1]");
+    expect(logObj?.["1"]).toBe("[P2]");
+    expect(logObj?.["2"]).toBe("[P3]");
+    expect(logObj?.["3"]).toBe("[P4]");
+    expect(logObj?.["4"]).toBe("msg");
+  });
+
+  test("settings override at arbitrary depth", () => {
+    const root = new Logger({ type: "hidden", minLevel: 0 });
+    const child = root.getSubLogger({ minLevel: 4 });
+    const grandchild = child.getSubLogger({});
+
+    expect(root.info("ok")).toBeDefined();
+    expect(child.info("skipped")).toBeUndefined();
+    expect(child.warn("ok")).toBeDefined();
+    expect(grandchild.info("also skipped")).toBeUndefined();
+    expect(grandchild.warn("ok")).toBeDefined();
+  });
+
+  test("transport on parent is inherited by child sub-logger", () => {
+    const captured: unknown[] = [];
+    const root = new Logger({ type: "hidden" });
+    root.attachTransport((logObj) => captured.push(logObj));
+
+    const child = root.getSubLogger({ name: "child" });
+    root.info("root msg");
+    child.info("child msg");
+
+    // child inherits parent's attachedTransports via getSubLogger settings spread
+    expect(captured.length).toBe(2);
+    expect((captured[0] as Record<string, unknown>)["0"]).toBe("root msg");
+    expect((captured[1] as Record<string, unknown>)["0"]).toBe("child msg");
+  });
+
+  test("sub-logger with independent logObj at each level", () => {
+    const rootObj = { level: "root", shared: true };
+    const root = new Logger({ type: "hidden" }, rootObj);
+
+    const childObj = { level: "child", shared: false };
+    const child = root.getSubLogger({}, childObj);
+
+    const rootLog = root.info("r");
+    expect(rootLog?.level).toBe("root");
+    expect(rootLog?.shared).toBe(true);
+
+    const childLog = child.info("c");
+    expect(childLog?.level).toBe("child");
+    expect(childLog?.shared).toBe(false);
+  });
+
+  test("sub-logger inherits type from parent", () => {
+    const root = new Logger({ type: "hidden" });
+    const child = root.getSubLogger({});
+
+    expect(child.settings.type).toBe("hidden");
+  });
+
+  test("sub-logger with attachedTransports in settings", () => {
+    const captured: unknown[] = [];
+    const root = new Logger({ type: "hidden" });
+    const child = root.getSubLogger({
+      attachedTransports: [(logObj) => captured.push(logObj)],
+    });
+
+    child.info("from child");
+
+    expect(captured.length).toBe(1);
+    expect((captured[0] as Record<string, unknown>)["0"]).toBe("from child");
+  });
+});

tests/26_advanced_masking.test.ts

@@ -0,0 +1,131 @@
+import { Logger } from "../src/index.js";
+
+describe("Advanced masking", () => {
+  test("masks keys in deeply nested structure (5+ levels)", () => {
+    const logger = new Logger({ type: "hidden", maskValuesOfKeys: ["secret"] });
+    const input = {
+      a: {
+        b: {
+          c: {
+            d: {
+              e: {
+                secret: "top-secret-value",
+                visible: "ok",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const logObj = logger.info(input);
+    const nested = (logObj as Record<string, unknown>)?.a as Record<string, unknown>;
+    const deep = (nested?.b as Record<string, unknown>)?.c as Record<string, unknown>;
+    const deeper = (deep?.d as Record<string, unknown>)?.e as Record<string, unknown>;
+
+    expect(deeper?.secret).toBe("[***]");
+    expect(deeper?.visible).toBe("ok");
+  });
+
+  test("masks keys in circular structures without throwing", () => {
+    const logger = new Logger({ type: "hidden", maskValuesOfKeys: ["password"] });
+    const obj: Record<string, unknown> = { password: "secret123", name: "test" };
+    obj.self = obj;
+
+    expect(() => {
+      const logObj = logger.info(obj);
+      expect(logObj?.password).toBe("[***]");
+      expect(logObj?.name).toBe("test");
+    }).not.toThrow();
+  });
+
+  test("masking preserves Date instances", () => {
+    const logger = new Logger({ type: "hidden", maskValuesOfKeys: ["token"] });
+    const now = new Date();
+    const input = { token: "abc", created: now };
+
+    const logObj = logger.info(input);
+    expect(logObj?.token).toBe("[***]");
+    expect(logObj?.created).toBeInstanceOf(Date);
+    expect((logObj?.created as Date).getTime()).toBe(now.getTime());
+  });
+
+  test("masking preserves Map and Set instances", () => {
+    const logger = new Logger({ type: "hidden", maskValuesOfKeys: ["apiKey"] });
+    const map = new Map([["a", 1]]);
+    const set = new Set([1, 2, 3]);
+    const input = { apiKey: "key123", data: { map, set } };
+
+    const logObj = logger.info(input);
+    expect(logObj?.apiKey).toBe("[***]");
+    const data = logObj?.data as Record<string, unknown>;
+    expect(data?.map).toBeInstanceOf(Map);
+    expect(data?.set).toBeInstanceOf(Set);
+  });
+
+  test("masks keys within objects passed as multiple args", () => {
+    const logger = new Logger({ type: "hidden", maskValuesOfKeys: ["password"] });
+    const a = { user: "alice", password: "pass1" };
+    const b = { user: "bob", password: "pass2" };
+
+    const logObj = logger.info(a, b);
+    expect((logObj?.["0"] as Record<string, unknown>)?.password).toBe("[***]");
+    expect((logObj?.["1"] as Record<string, unknown>)?.password).toBe("[***]");
+    expect((logObj?.["0"] as Record<string, unknown>)?.user).toBe("alice");
+  });
+
+  test("key masking and regex masking work simultaneously", () => {
+    const logger = new Logger({
+      type: "hidden",
+      maskValuesOfKeys: ["password"],
+      maskValuesRegEx: [/\d{3}-\d{2}-\d{4}/],
+    });
+
+    const input = {
+      password: "secret",
+      message: "SSN is 123-45-6789",
+    };
+
+    const logObj = logger.info(input);
+    expect(logObj?.password).toBe("[***]");
+    expect(logObj?.message).toBe("SSN is [***]");
+  });
+
+  test("case-insensitive masking matches regardless of key casing", () => {
+    const logger = new Logger({
+      type: "hidden",
+      maskValuesOfKeys: ["password"],
+      maskValuesOfKeysCaseInsensitive: true,
+    });
+
+    const input = { Password: "a", PASSWORD: "b", pAsSwOrD: "c", other: "visible" };
+    const logObj = logger.info(input);
+
+    expect(logObj?.Password).toBe("[***]");
+    expect(logObj?.PASSWORD).toBe("[***]");
+    expect(logObj?.pAsSwOrD).toBe("[***]");
+    expect(logObj?.other).toBe("visible");
+  });
+
+  test("original input is not mutated after logging", () => {
+    const logger = new Logger({ type: "hidden", maskValuesOfKeys: ["password"] });
+    const input = { password: "original", nested: { password: "also-original" } };
+    const inputSnapshot = JSON.parse(JSON.stringify(input));
+
+    logger.info(input);
+
+    expect(input.password).toBe(inputSnapshot.password);
+    expect(input.nested.password).toBe(inputSnapshot.nested.password);
+  });
+
+  test("custom maskPlaceholder is used", () => {
+    const logger = new Logger({
+      type: "hidden",
+      maskValuesOfKeys: ["secret"],
+      maskPlaceholder: "<REDACTED>",
+    });
+
+    const logObj = logger.info({ secret: "value" });
+    expect(logObj?.secret).toBe("<REDACTED>");
+  });
+});

tests/27_advanced_errors.test.ts

@@ -0,0 +1,126 @@
+import { Logger } from "../src/index.js";
+
+class HttpError extends Error {
+  status: number;
+  constructor(message: string, status: number) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+  }
+}
+
+describe("Advanced error handling", () => {
+  test("custom error subclass with extra properties", () => {
+    const logger = new Logger({ type: "hidden" });
+    const err = new HttpError("Not Found", 404);
+    const logObj = logger.info(err);
+
+    expect(logObj?.nativeError).toBeInstanceOf(HttpError);
+    expect(logObj?.name).toBe("HttpError");
+    expect(logObj?.message).toBe("Not Found");
+    expect(logObj?.stack).toBeInstanceOf(Array);
+  });
+
+  test("error cause chain serializes nested causes", () => {
+    const logger = new Logger({ type: "hidden" });
+    const root = new Error("root cause");
+    const middle = new Error("middle", { cause: root });
+    const outer = new Error("outer", { cause: middle });
+
+    const logObj = logger.info(outer);
+
+    expect(logObj?.name).toBe("Error");
+    expect(logObj?.message).toBe("outer");
+    expect(logObj?.cause).toBeDefined();
+    expect(logObj?.cause?.message).toBe("middle");
+    expect(logObj?.cause?.cause?.message).toBe("root cause");
+  });
+
+  test("deep cause chain is capped at max depth", () => {
+    const logger = new Logger({ type: "hidden" });
+
+    // Build 8-level chain, expect capped at 5
+    let err: Error = new Error("level-0");
+    for (let i = 1; i <= 7; i++) {
+      err = new Error(`level-${i}`, { cause: err });
+    }
+
+    const logObj = logger.info(err);
+
+    let current = logObj as Record<string, unknown> | undefined;
+    let depth = 0;
+    while (current?.cause != null) {
+      depth++;
+      current = current.cause as Record<string, unknown>;
+    }
+
+    expect(depth).toBeLessThanOrEqual(5);
+  });
+
+  test("non-Error cause value (string) is wrapped", () => {
+    const logger = new Logger({ type: "hidden" });
+    const err = new Error("main") as Error & { cause: string };
+    err.cause = "string cause";
+
+    const logObj = logger.info(err);
+
+    expect(logObj?.cause).toBeDefined();
+    expect(logObj?.cause?.nativeError).toBeInstanceOf(Error);
+  });
+
+  test("non-Error cause value (object) is wrapped", () => {
+    const logger = new Logger({ type: "hidden" });
+    const err = new Error("main") as Error & { cause: unknown };
+    err.cause = { code: 404, msg: "not found" };
+
+    const logObj = logger.info(err);
+
+    expect(logObj?.cause).toBeDefined();
+    expect(logObj?.cause?.nativeError).toBeInstanceOf(Error);
+  });
+
+  test("AggregateError is logged without throwing", () => {
+    const logger = new Logger({ type: "hidden" });
+    const agg = new AggregateError([new Error("e1"), new Error("e2")], "multiple errors");
+
+    expect(() => {
+      const logObj = logger.info(agg);
+      expect(logObj).toBeDefined();
+      expect(logObj?.name).toBe("AggregateError");
+      expect(logObj?.message).toBe("multiple errors");
+    }).not.toThrow();
+  });
+
+  test("error with empty stack does not throw", () => {
+    const logger = new Logger({ type: "hidden" });
+    const err = new Error("no stack");
+    err.stack = undefined;
+
+    expect(() => {
+      const logObj = logger.info(err);
+      expect(logObj).toBeDefined();
+      expect(logObj?.stack).toBeInstanceOf(Array);
+    }).not.toThrow();
+  });
+
+  test("error with non-standard stack format degrades gracefully", () => {
+    const logger = new Logger({ type: "hidden" });
+    const err = new Error("weird");
+    err.stack = "CUSTOM_FORMAT: weird\n-- custom frame info --";
+
+    expect(() => {
+      const logObj = logger.info(err);
+      expect(logObj).toBeDefined();
+    }).not.toThrow();
+  });
+
+  test("TypeError and RangeError preserve correct name", () => {
+    const logger = new Logger({ type: "hidden" });
+
+    const typeErr = logger.info(new TypeError("bad type"));
+    expect(typeErr?.name).toBe("TypeError");
+
+    const rangeErr = logger.info(new RangeError("out of range"));
+    expect(rangeErr?.name).toBe("RangeError");
+  });
+});