node-avo-inspector 1.1.1 → 1.2.0

package/dist/__tests__/TestAvoEventSpecCache.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AvoEventSpecCache_1 = require("../eventSpec/AvoEventSpecCache");
+function makeSpec(eventName) {
+    return {
+        eventSpec: {
+            eventName,
+            properties: [{ propertyName: "prop1", propertyType: "string" }],
+        },
+        metadata: {
+            schemaId: "schema1",
+            branchId: "branch1",
+            latestActionId: "action1",
+            sourceId: "source1",
+        },
+    };
+}
+describe("AvoEventSpecCache", () => {
+    let cache;
+    beforeEach(() => {
+        cache = new AvoEventSpecCache_1.AvoEventSpecCache();
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    test("returns undefined for cache miss", () => {
+        expect(cache.get("nonexistent")).toBeUndefined();
+    });
+    test("stores and retrieves a value", () => {
+        const spec = makeSpec("click");
+        cache.set("key1", spec);
+        expect(cache.get("key1")).toEqual(spec);
+    });
+    test("stores and retrieves null responses", () => {
+        const nullSpec = {
+            eventSpec: null,
+            metadata: {
+                schemaId: "s1",
+                branchId: "b1",
+                latestActionId: "a1",
+                sourceId: "src1",
+            },
+        };
+        cache.set("null-key", nullSpec);
+        expect(cache.get("null-key")).toEqual(nullSpec);
+    });
+    test("TTL eviction: entries older than 60s removed on next sweep", () => {
+        cache.set("old-key", makeSpec("old"));
+        // Advance time by 61 seconds
+        jest.advanceTimersByTime(61000);
+        // Trigger sweep by performing enough operations
+        for (let i = 0; i < 50; i++) {
+            cache.set(`sweep-${i}`, makeSpec(`sweep-${i}`));
+        }
+        expect(cache.get("old-key")).toBeUndefined();
+    });
+    test("per-entry eviction: entries retrieved 50+ times evicted on next get", () => {
+        cache.set("hot-key", makeSpec("hot"));
+        // Access 49 times - should still be present
+        for (let i = 0; i < 49; i++) {
+            expect(cache.get("hot-key")).toBeDefined();
+        }
+        // The 50th access should trigger eviction
+        expect(cache.get("hot-key")).toBeUndefined();
+    });
+    test("LRU eviction when size > 50", () => {
+        // Fill cache with 50 entries. Each set() creates an entry with
+        // lastAccessed = Date.now(). We advance the fake clock by 1ms between
+        // sets so every entry has a distinct timestamp.
+        // The 50th set triggers evictLRU(), which removes the entry with the
+        // oldest lastAccessed — that is entry-0 (set at t=0).
+        for (let i = 0; i < 50; i++) {
+            cache.set(`entry-${i}`, makeSpec(`event-${i}`));
+            jest.advanceTimersByTime(1);
+        }
+        // entry-0 was the oldest when evictLRU() fired on the 50th set,
+        // so it should have been removed.
+        expect(cache.get("entry-0")).toBeUndefined();
+        // Touch entry-1 via get() — this updates its lastAccessed to "now",
+        // making it the most-recently-accessed entry and protecting it from
+        // the next eviction.
+        expect(cache.get("entry-1")).toBeDefined();
+        jest.advanceTimersByTime(1);
+        // Add two more entries to push the cache over 50 again.
+        // Each set that crosses the 50-entry threshold triggers evictLRU().
+        cache.set("entry-50", makeSpec("event-50"));
+        jest.advanceTimersByTime(1);
+        cache.set("entry-51", makeSpec("event-51"));
+        // entry-2 was never touched after its initial set(), so it had the
+        // oldest lastAccessed among remaining entries — evictLRU() removes it.
+        expect(cache.get("entry-2")).toBeUndefined();
+        // entry-1 survives because get() above refreshed its lastAccessed,
+        // so it was NOT the oldest entry when eviction fired.
+        expect(cache.get("entry-1")).toBeDefined();
+        // entry-51 was just inserted, so it is definitely still present.
+        expect(cache.get("entry-51")).toBeDefined();
+    });
+    test("global rotation evicts LRU entry every 50 operations", () => {
+        // Add entries with distinct timestamps
+        for (let i = 0; i < 49; i++) {
+            cache.set(`entry-${i}`, makeSpec(`event-${i}`));
+            jest.advanceTimersByTime(1);
+        }
+        // The 50th set triggers global rotation, evicting the LRU entry (entry-0)
+        cache.set("entry-49", makeSpec("event-49"));
+        expect(cache.get("entry-0")).toBeUndefined();
+        expect(cache.get("entry-49")).toBeDefined();
+    });
+    test("flush on empty cache is a no-op", () => {
+        // Just verify no crash
+        cache.flush();
+        expect(cache.get("anything")).toBeUndefined();
+    });
+    test("flush clears all entries", () => {
+        cache.set("a", makeSpec("a"));
+        cache.set("b", makeSpec("b"));
+        cache.flush();
+        expect(cache.get("a")).toBeUndefined();
+        expect(cache.get("b")).toBeUndefined();
+    });
+    test("key format uses null-byte delimiter", () => {
+        const key = AvoEventSpecCache_1.AvoEventSpecCache.makeKey("myApi", "stream1", "click");
+        expect(key).toBe("myApi\0stream1\0click");
+    });
+    describe("contains()", () => {
+        test("returns true for a valid cached entry", () => {
+            cache.set("k1", makeSpec("click"));
+            expect(cache.contains("k1")).toBe(true);
+        });
+        test("returns false for a missing key", () => {
+            expect(cache.contains("nonexistent")).toBe(false);
+        });
+        test("returns false after TTL expiry", () => {
+            cache.set("ttl-key", makeSpec("click"));
+            jest.advanceTimersByTime(61000);
+            expect(cache.contains("ttl-key")).toBe(false);
+        });
+        test("returns false after access count exhaustion", () => {
+            cache.set("hot-key", makeSpec("hot"));
+            // Access 49 times via get to increment eventCount to 49
+            for (let i = 0; i < 49; i++) {
+                cache.get("hot-key");
+            }
+            // eventCount is now 49; contains() checks >= 50, so still false at 49
+            // but the 50th get() returned undefined and deleted the entry
+            // Actually the 50th get increments to 50 and evicts, so after 49 gets
+            // eventCount is 49. The next get (50th) increments to 50 and evicts.
+            // contains() checks >= MAX_EVENT_COUNT without incrementing, so at 49 it's true.
+            // We need one more get to push it to 50.
+            expect(cache.get("hot-key")).toBeUndefined(); // 50th access evicts
+            expect(cache.contains("hot-key")).toBe(false);
+        });
+    });
+    describe("upsert/overwrite", () => {
+        test("setting the same key twice overwrites the previous value", () => {
+            const spec1 = makeSpec("first");
+            const spec2 = makeSpec("second");
+            cache.set("dup-key", spec1);
+            expect(cache.get("dup-key")).toEqual(spec1);
+            cache.set("dup-key", spec2);
+            expect(cache.get("dup-key")).toEqual(spec2);
+        });
+        test("overwrite resets timestamp", () => {
+            cache.set("ts-key", makeSpec("event"));
+            // Advance time close to TTL
+            jest.advanceTimersByTime(55000);
+            // Overwrite — should reset the timestamp
+            cache.set("ts-key", makeSpec("event-v2"));
+            // Advance another 10s (total 65s since first set, but only 10s since overwrite)
+            jest.advanceTimersByTime(10000);
+            expect(cache.get("ts-key")).toBeDefined();
+        });
+        test("overwrite resets eventCount", () => {
+            cache.set("count-key", makeSpec("event"));
+            // Access 48 times to bring eventCount close to limit
+            for (let i = 0; i < 48; i++) {
+                cache.get("count-key");
+            }
+            // Overwrite — should reset eventCount to 0
+            cache.set("count-key", makeSpec("event-v2"));
+            // Should be able to access again without hitting the limit
+            expect(cache.get("count-key")).toBeDefined();
+            expect(cache.get("count-key")).toBeDefined();
+        });
+    });
+    describe("makeKey delimiter collision", () => {
+        test("makeKey with null-byte delimiter prevents colon collisions", () => {
+            const key1 = AvoEventSpecCache_1.AvoEventSpecCache.makeKey("a:b", "c", "d");
+            const key2 = AvoEventSpecCache_1.AvoEventSpecCache.makeKey("a", "b:c", "d");
+            expect(key1).not.toBe(key2);
+        });
+    });
+});

package/dist/__tests__/TestAvoEventSpecFetcher.d.ts

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

package/dist/__tests__/TestAvoEventSpecFetcher.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AvoEventSpecFetcher_1 = require("../eventSpec/AvoEventSpecFetcher");
+const https = require("https");
+const events_1 = require("events");
+jest.mock("https");
+const mockedHttps = https;
+class MockIncomingMessage extends events_1.EventEmitter {
+    constructor(statusCode) {
+        super();
+        this.statusCode = statusCode;
+    }
+}
+class MockClientRequest extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.end = jest.fn();
+        this.destroy = jest.fn();
+        this.setTimeout = jest.fn();
+    }
+}
+/** Build a wire-format response body matching the /trackingPlan/eventSpec API */
+function wireResponse(eventName, properties, metadata) {
+    const p = {};
+    for (const [name, constraint] of Object.entries(properties)) {
+        p[name] = { t: constraint.t, r: true };
+    }
+    return {
+        events: [{ b: metadata.branchId, id: "evt1", vids: [], p }],
+        metadata,
+    };
+}
+function setupMockRequest(responseStatusCode, responseBody) {
+    const mockReq = new MockClientRequest();
+    const mockRes = new MockIncomingMessage(responseStatusCode);
+    mockedHttps.request.mockImplementation((_options, callback) => {
+        callback(mockRes);
+        const data = JSON.stringify(responseBody);
+        mockRes.emit("data", Buffer.from(data));
+        mockRes.emit("end");
+        return mockReq;
+    });
+    return mockReq;
+}
+function setupMockRequestError() {
+    const mockReq = new MockClientRequest();
+    mockedHttps.request.mockImplementation((_options, _callback) => {
+        process.nextTick(() => mockReq.emit("error", new Error("network failure")));
+        return mockReq;
+    });
+    return mockReq;
+}
+describe("AvoEventSpecFetcher", () => {
+    let fetcher;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fetcher = new AvoEventSpecFetcher_1.AvoEventSpecFetcher("test-api-key");
+    });
+    afterEach(() => {
+        fetcher.destroy();
+    });
+    test("fetches event spec via HTTPS GET", (done) => {
+        const metadata = { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" };
+        const wire = wireResponse("click", { target: { t: "string" } }, metadata);
+        const expectedParsed = {
+            eventSpec: {
+                eventName: "click",
+                properties: [{ propertyName: "target", propertyType: "string" }],
+            },
+            metadata,
+        };
+        setupMockRequest(200, wire);
+        fetcher.fetch("click", "stream1", (result) => {
+            expect(result).toEqual(expectedParsed);
+            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
+            const callArgs = mockedHttps.request.mock.calls[0][0];
+            expect(callArgs.method).toBe("GET");
+            expect(callArgs.hostname).toBe("api.avo.app");
+            done();
+        });
+    });
+    test("in-flight dedup: exactly ONE https.request for concurrent same-key events", (done) => {
+        const metadata = { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" };
+        const wire = wireResponse("purchase", {}, metadata);
+        const expectedParsed = {
+            eventSpec: { eventName: "purchase", properties: [] },
+            metadata,
+        };
+        // Delay the response so both calls are in-flight
+        const mockReq = new MockClientRequest();
+        const mockRes = new MockIncomingMessage(200);
+        mockedHttps.request.mockImplementation((_options, callback) => {
+            // Defer the response
+            setTimeout(() => {
+                callback(mockRes);
+                const data = JSON.stringify(wire);
+                mockRes.emit("data", Buffer.from(data));
+                mockRes.emit("end");
+            }, 10);
+            return mockReq;
+        });
+        let callCount = 0;
+        const checkDone = (result) => {
+            callCount++;
+            expect(result).toEqual(expectedParsed);
+            if (callCount === 2) {
+                // Only ONE actual https.request
+                expect(mockedHttps.request).toHaveBeenCalledTimes(1);
+                done();
+            }
+        };
+        fetcher.fetch("purchase", "stream1", checkDone);
+        fetcher.fetch("purchase", "stream1", checkDone);
+    });
+    test("in-flight failure: all queued callbacks resolved with null", (done) => {
+        setupMockRequestError();
+        let callCount = 0;
+        const checkDone = (result) => {
+            callCount++;
+            expect(result).toBeNull();
+            if (callCount === 2) {
+                expect(mockedHttps.request).toHaveBeenCalledTimes(1);
+                done();
+            }
+        };
+        fetcher.fetch("fail-event", "stream1", checkDone);
+        fetcher.fetch("fail-event", "stream1", checkDone);
+    });
+    test("non-200 status code resolves callback with null", (done) => {
+        setupMockRequest(500, { error: "Internal Server Error" });
+        fetcher.fetch("click", "stream1", (result) => {
+            expect(result).toBeNull();
+            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
+            done();
+        });
+    });
+    test("malformed JSON body resolves callback with null", (done) => {
+        const mockReq = new MockClientRequest();
+        const mockRes = new MockIncomingMessage(200);
+        mockedHttps.request.mockImplementation((_options, callback) => {
+            callback(mockRes);
+            mockRes.emit("data", Buffer.from("not valid json {{{"));
+            mockRes.emit("end");
+            return mockReq;
+        });
+        fetcher.fetch("click", "stream1", (result) => {
+            expect(result).toBeNull();
+            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
+            done();
+        });
+    });
+    test("timeout resolves callback with null", (done) => {
+        const mockReq = new MockClientRequest();
+        mockedHttps.request.mockImplementation((_options, _callback) => {
+            // Simulate timeout: never call the response callback,
+            // instead emit "timeout" on next tick
+            process.nextTick(() => mockReq.emit("timeout"));
+            return mockReq;
+        });
+        fetcher.fetch("click", "stream1", (result) => {
+            expect(result).toBeNull();
+            expect(mockReq.destroy).toHaveBeenCalled();
+            expect(mockedHttps.request).toHaveBeenCalledTimes(1);
+            done();
+        });
+    });
+    test("separate keys make separate requests", (done) => {
+        const metadata = { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" };
+        const wire = wireResponse("click", {}, metadata);
+        const expectedParsed = {
+            eventSpec: { eventName: "click", properties: [] },
+            metadata,
+        };
+        setupMockRequest(200, wire);
+        let callCount = 0;
+        const checkDone = () => {
+            callCount++;
+            if (callCount === 2) {
+                expect(mockedHttps.request).toHaveBeenCalledTimes(2);
+                done();
+            }
+        };
+        fetcher.fetch("click", "stream1", (result) => {
+            expect(result).toEqual(expectedParsed);
+            checkDone();
+        });
+        fetcher.fetch("purchase", "stream1", (result) => {
+            // Both resolve with the same mock but that's fine for this test
+            checkDone();
+        });
+    });
+    test("parseWireResponse transforms wire format correctly", () => {
+        const wire = {
+            events: [{
+                    b: "main",
+                    id: "evt1",
+                    vids: [],
+                    p: {
+                        "Cli Action": { t: "string", r: true, v: { '["Status","Pull"]': ["evt1"] } },
+                        "Client": { t: "string", r: true },
+                    },
+                }],
+            metadata: { schemaId: "s1", branchId: "main", latestActionId: "a1", sourceId: "src1" },
+        };
+        const result = AvoEventSpecFetcher_1.AvoEventSpecFetcher.parseWireResponse(wire, "Cli Invoked");
+        expect(result.metadata).toEqual({ schemaId: "s1", branchId: "main", latestActionId: "a1", sourceId: "src1" });
+        expect(result.eventSpec).not.toBeNull();
+        expect(result.eventSpec.eventName).toBe("Cli Invoked");
+        expect(result.eventSpec.properties).toEqual([
+            { propertyName: "Cli Action", propertyType: "string" },
+            { propertyName: "Client", propertyType: "string" },
+        ]);
+    });
+    test("parseWireResponse returns null eventSpec for empty events array", () => {
+        const wire = { events: [], metadata: { schemaId: "s1", branchId: "b1", latestActionId: "a1", sourceId: "src1" } };
+        const result = AvoEventSpecFetcher_1.AvoEventSpecFetcher.parseWireResponse(wire, "test");
+        expect(result.eventSpec).toBeNull();
+    });
+});

package/dist/__tests__/TestAvoInspector.js

@@ -12,7 +12,7 @@ describe("Initialization", () => {
         let inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
         inspector.enableLogging(true);
         expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledTimes(1);
-        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith(apiKey, env, "my-test-app", version, inspectorVersion);
+        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith(apiKey, env, "my-test-app", version, inspectorVersion, undefined);
     });
     test("Api Key is set", () => {
         // Given
@@ -40,7 +40,7 @@ describe("Initialization", () => {
             });
         }).toThrow(constants_1.error.API_KEY);
     });
-    test("Error is thrown when empty Api Key is used", () => {
+    test("Error is thrown when whitespace Api Key is used", () => {
         // Given
         const apiKey = " ";
         // Then
@@ -52,6 +52,15 @@ describe("Initialization", () => {
             });
         }).toThrow(constants_1.error.API_KEY);
     });
+    test("Error is thrown when empty string Api Key is used", () => {
+        expect(() => {
+            new AvoInspector_1.AvoInspector({
+                env: AvoInspectorEnv_1.AvoInspectorEnv.Prod,
+                version: "0",
+                apiKey: "",
+            });
+        }).toThrow(constants_1.error.API_KEY);
+    });
     test("Error is thrown when Api Key is set to null", () => {
         // Given
         const apiKey = null;
@@ -214,4 +223,69 @@ describe("Initialization", () => {
             });
         }).toThrow(constants_1.error.VERSION);
     });
+    test("publicEncryptionKey is forwarded to AvoNetworkCallsHandler when provided", () => {
+        const inspectorVersion = process.env.npm_package_version || "";
+        AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.mockClear();
+        let inspector = new AvoInspector_1.AvoInspector({
+            apiKey: "api-key-xxx",
+            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
+            version: "1",
+            publicEncryptionKey: "my-public-key-123",
+        });
+        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith("api-key-xxx", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "", "1", inspectorVersion, "my-public-key-123");
+    });
+    test("publicEncryptionKey is forwarded as undefined to AvoNetworkCallsHandler when not provided", () => {
+        const inspectorVersion = process.env.npm_package_version || "";
+        AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.mockClear();
+        let inspector = new AvoInspector_1.AvoInspector({
+            apiKey: "api-key-xxx",
+            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
+            version: "1",
+        });
+        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith("api-key-xxx", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "", "1", inspectorVersion, undefined);
+    });
+    test("warns when publicEncryptionKey is malformed in dev/staging", () => {
+        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        new AvoInspector_1.AvoInspector({
+            apiKey: "api-key-xxx",
+            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
+            version: "1",
+            publicEncryptionKey: "not-valid-hex",
+        });
+        expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("publicEncryptionKey does not look like a valid"));
+        consoleWarnSpy.mockRestore();
+    });
+    test("does not warn when publicEncryptionKey is a valid 130-char uncompressed hex key in dev/staging", () => {
+        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        const validKey = "04" + "ab".repeat(64); // 2 + 128 = 130 hex chars
+        new AvoInspector_1.AvoInspector({
+            apiKey: "api-key-xxx",
+            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
+            version: "1",
+            publicEncryptionKey: validKey,
+        });
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        consoleWarnSpy.mockRestore();
+    });
+    test("does not warn when publicEncryptionKey is a valid 66-char compressed hex key in dev/staging", () => {
+        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        const validKey = "02" + "4e".repeat(32); // 2 + 64 = 66 hex chars
+        new AvoInspector_1.AvoInspector({
+            apiKey: "api-key-xxx",
+            env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
+            version: "1",
+            publicEncryptionKey: validKey,
+        });
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        consoleWarnSpy.mockRestore();
+    });
+    test("constructor works without publicEncryptionKey (backwards compatible)", () => {
+        expect(() => {
+            new AvoInspector_1.AvoInspector({
+                apiKey: "api-key-xxx",
+                env: AvoInspectorEnv_1.AvoInspectorEnv.Dev,
+                version: "1",
+            });
+        }).not.toThrow();
+    });
 });

package/dist/__tests__/TestAvoStreamId.d.ts

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

package/dist/__tests__/TestAvoStreamId.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AvoStreamId_1 = require("../AvoStreamId");
+describe("AvoStreamId", () => {
+    let consoleWarnSpy;
+    beforeEach(() => {
+        consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test("streamId getter returns empty string by default", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId();
+        expect(avoStreamId.streamId).toBe("");
+    });
+    test("streamId getter returns the value passed to constructor", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId("my-stream-id");
+        expect(avoStreamId.streamId).toBe("my-stream-id");
+    });
+    test("streamId containing ':' logs a warning", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId("invalid:stream:id");
+        const id = avoStreamId.streamId;
+        expect(consoleWarnSpy).toHaveBeenCalledWith("[Avo Inspector] Warning: streamId contains ':' which is not supported");
+        expect(id).toBe("invalid:stream:id");
+    });
+    test("streamId without ':' does not log a warning", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId("valid-stream-id");
+        const id = avoStreamId.streamId;
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(id).toBe("valid-stream-id");
+    });
+    test("empty streamId does not log a warning", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId("");
+        const id = avoStreamId.streamId;
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(id).toBe("");
+    });
+    test("explicit undefined arg returns empty string and does not warn", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId(undefined);
+        const id = avoStreamId.streamId;
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(id).toBe("");
+    });
+    test("warning is only logged once per instance, not on every .streamId access", () => {
+        const avoStreamId = new AvoStreamId_1.AvoStreamId("bad:id");
+        // The warning is logged in the constructor, so it's already been called once
+        expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+        // Access streamId multiple times
+        avoStreamId.streamId;
+        avoStreamId.streamId;
+        avoStreamId.streamId;
+        // Should still be only one warning total
+        expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/__tests__/TestEventValidator.d.ts

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