node-avo-inspector 1.1.1 → 1.2.0

package/src/__tests__/TestAvoStreamId.ts

@@ -0,0 +1,72 @@
+import { AvoStreamId } from "../AvoStreamId";
+
+describe("AvoStreamId", () => {
+  let consoleWarnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("streamId getter returns empty string by default", () => {
+    const avoStreamId = new AvoStreamId();
+    expect(avoStreamId.streamId).toBe("");
+  });
+
+  test("streamId getter returns the value passed to constructor", () => {
+    const avoStreamId = new AvoStreamId("my-stream-id");
+    expect(avoStreamId.streamId).toBe("my-stream-id");
+  });
+
+  test("streamId containing ':' logs a warning", () => {
+    const avoStreamId = new 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("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("");
+    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(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("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/src/__tests__/TestEventValidator.ts

@@ -0,0 +1,231 @@
+import { EventValidator } from "../eventSpec/EventValidator";
+import { EventSpec, PropertyConstraint, PropertyValidationResult } from "../eventSpec/AvoEventSpecFetchTypes";
+
+// We need to mock safe-regex2 for some tests
+jest.mock("safe-regex2", () => {
+  const actual = jest.requireActual("safe-regex2");
+  return {
+    __esModule: true,
+    default: actual.default || actual,
+    _mockable: true,
+  };
+});
+
+describe("EventValidator", () => {
+  let validator: EventValidator;
+
+  beforeEach(() => {
+    validator = new EventValidator();
+    jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("type validation", () => {
+    test("passes when property types match spec", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [
+          { propertyName: "target", propertyType: "string" },
+          { propertyName: "count", propertyType: "int" },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "target", propertyType: "string" },
+        { propertyName: "count", propertyType: "int" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-1");
+      // All properties passed type check, so failedEventIds should be empty
+      expect(results.every((r: PropertyValidationResult) => r.failedEventIds.length === 0)).toBe(true);
+      // Bandwidth optimization: passedEventIds cleared because passed >= failed for each property
+      expect(results.every((r: PropertyValidationResult) => r.passedEventIds.length === 0)).toBe(true);
+    });
+
+    test("fails when property type does not match spec", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [{ propertyName: "count", propertyType: "int" }],
+      };
+      const eventProperties = [
+        { propertyName: "count", propertyType: "string" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-2");
+      const countResult = results.find((r: PropertyValidationResult) => r.propertyName === "count");
+      expect(countResult?.failedEventIds).toContain("evt-2");
+      expect(countResult?.passedEventIds).not.toContain("evt-2");
+    });
+
+    test("fails for missing required properties", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [
+          { propertyName: "target", propertyType: "string" },
+          { propertyName: "count", propertyType: "int" },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "target", propertyType: "string" },
+        // count is missing
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-3");
+      const countResult = results.find((r: PropertyValidationResult) => r.propertyName === "count");
+      expect(countResult?.failedEventIds).toContain("evt-3");
+    });
+  });
+
+  describe("regex validation", () => {
+    test("passes when value matches safe regex pattern (type match)", () => {
+      const spec: EventSpec = {
+        eventName: "navigate",
+        properties: [
+          {
+            propertyName: "url",
+            propertyType: "string",
+            regex: "^https://",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "url", propertyType: "string", propertyValue: "https://example.com" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-4");
+      const urlResult = results.find((r: PropertyValidationResult) => r.propertyName === "url");
+      // Type matches and regex matches, property passed. Bandwidth optimization: passedEventIds cleared
+      // because passed count (1) >= failed count (0)
+      expect(urlResult?.failedEventIds).toEqual([]);
+    });
+
+    test("fails when value does not match safe regex pattern", () => {
+      const spec: EventSpec = {
+        eventName: "navigate",
+        properties: [
+          {
+            propertyName: "url",
+            propertyType: "string",
+            regex: "^https://",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "url", propertyType: "string", propertyValue: "http://example.com" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-regex-fail");
+      const urlResult = results.find((r: PropertyValidationResult) => r.propertyName === "url");
+      expect(urlResult?.failedEventIds).toContain("evt-regex-fail");
+      expect(urlResult?.passedEventIds).not.toContain("evt-regex-fail");
+    });
+
+    test("logs warning and passes type check when regex syntax is invalid", () => {
+      const spec: EventSpec = {
+        eventName: "filter",
+        properties: [
+          {
+            propertyName: "pattern",
+            propertyType: "string",
+            regex: "[invalid",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "pattern", propertyType: "string", propertyValue: "anything" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-bad-regex");
+      const patternResult = results.find((r: PropertyValidationResult) => r.propertyName === "pattern");
+      // Invalid regex is caught, property still passes type check
+      expect(patternResult?.failedEventIds).toEqual([]);
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining("[Avo Inspector] Warning")
+      );
+    });
+
+    test("skips unsafe regex patterns with warning", () => {
+      const spec: EventSpec = {
+        eventName: "search",
+        properties: [
+          {
+            propertyName: "query",
+            propertyType: "string",
+            // Catastrophic backtracking pattern
+            regex: "(a+)+$",
+          },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "query", propertyType: "string", propertyValue: "aaa" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-5");
+      // Unsafe regex should be skipped, property still passes type check
+      const queryResult = results.find((r: PropertyValidationResult) => r.propertyName === "query");
+      // Bandwidth optimization: passedEventIds cleared because passed count >= failed count
+      expect(queryResult?.failedEventIds).toEqual([]);
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining("[Avo Inspector] Warning")
+      );
+    });
+  });
+
+  describe("extra/unexpected properties", () => {
+    test("ignores properties present in event but not in the spec", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [
+          { propertyName: "target", propertyType: "string" },
+        ],
+      };
+      const eventProperties = [
+        { propertyName: "target", propertyType: "string" },
+        { propertyName: "extraProp", propertyType: "int" },
+        { propertyName: "anotherExtra", propertyType: "boolean" },
+      ];
+
+      const results = validator.validate(spec, eventProperties, "evt-extra");
+      // Only spec properties get results — extra properties are not reported
+      expect(results).toHaveLength(1);
+      expect(results[0].propertyName).toBe("target");
+      expect(results.find((r: PropertyValidationResult) => r.propertyName === "extraProp")).toBeUndefined();
+      expect(results.find((r: PropertyValidationResult) => r.propertyName === "anotherExtra")).toBeUndefined();
+    });
+  });
+
+  describe("bandwidth optimization", () => {
+    test("returns passedEventIds only when strictly smaller than failedEventIds", () => {
+      const spec: EventSpec = {
+        eventName: "click",
+        properties: [{ propertyName: "target", propertyType: "string" }],
+      };
+
+      // Single pass
+      const passResults = validator.validate(
+        spec,
+        [{ propertyName: "target", propertyType: "string" }],
+        "evt-pass"
+      );
+      const passResult = passResults.find((r: PropertyValidationResult) => r.propertyName === "target");
+
+      // When there's only passed and no failed, passedEventIds count (1) > failedEventIds count (0)
+      // So passedEventIds is NOT strictly smaller - it should be returned
+      // But the optimization says: return passedEventIds ONLY when strictly smaller than failedEventIds
+      // So when passedEventIds.length >= failedEventIds.length, we clear passedEventIds
+      expect(passResult?.passedEventIds).toEqual([]);
+
+      // Single fail
+      const failResults = validator.validate(
+        spec,
+        [{ propertyName: "target", propertyType: "int" }],
+        "evt-fail"
+      );
+      const failResult = failResults.find((r: PropertyValidationResult) => r.propertyName === "target");
+      // failedEventIds has 1, passedEventIds has 0 -> passedEventIds is strictly smaller, return it
+      expect(failResult?.failedEventIds).toContain("evt-fail");
+    });
+  });
+});

package/src/__tests__/TestNetworkCallsHandler.ts

@@ -15,7 +15,6 @@ describe("NetworkCallsHandler", () => {
   let networkHandler: AvoNetworkCallsHandler;
   let baseBody: BaseBody;
 
-  const customCallback = jest.fn();
   const now = new Date();
 
   beforeAll(() => {
@@ -43,8 +42,9 @@ describe("NetworkCallsHandler", () => {
       libPlatform: "node",
       messageId: mockedReturns.GUID,
       trackingId: "",
+      sessionId: "",
+      anonymousId: "",
       createdAt: new Date().toISOString(),
-      sessionId: mockedReturns.SESSION_ID,
       samplingRate: 1.0,
     };
   });
@@ -53,23 +53,12 @@ describe("NetworkCallsHandler", () => {
     jest.clearAllMocks();
   });
 
-  test("bodyForSessionStartedCall returns base body + session started body used for session started", () => {
-    const body = networkHandler.bodyForSessionStartedCall(
-      mockedReturns.SESSION_ID
-    );
-
-    expect(body).toEqual({
-      ...baseBody,
-      type: "sessionStarted",
-    });
-  });
-
   test("bodyForEventSchemaCall returns base body + event schema used for event sending from non Codegen", () => {
     const eventName = "event name";
     const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
 
     const body = networkHandler.bodyForEventSchemaCall(
-      mockedReturns.SESSION_ID,
+      "",
       eventName,
       eventProperties,
       null,
@@ -78,6 +67,7 @@ describe("NetworkCallsHandler", () => {
 
     expect(body).toEqual({
       ...baseBody,
+      anonymousId: "",
       type: "event",
       eventName,
       eventProperties,
@@ -94,7 +84,7 @@ describe("NetworkCallsHandler", () => {
     const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
 
     const body = networkHandler.bodyForEventSchemaCall(
-      mockedReturns.SESSION_ID,
+      "",
       eventName,
       eventProperties,
       eventId,
@@ -103,6 +93,7 @@ describe("NetworkCallsHandler", () => {
 
     expect(body).toEqual({
       ...baseBody,
+      anonymousId: "",
       type: "event",
       eventName,
       eventProperties,
@@ -111,4 +102,80 @@ describe("NetworkCallsHandler", () => {
       eventHash,
     });
   });
+
+  test("bodyForEventSchemaCall uses streamId as anonymousId", () => {
+    const eventName = "event name";
+    const streamId = "user-123";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+
+    const body = networkHandler.bodyForEventSchemaCall(
+      streamId,
+      eventName,
+      eventProperties,
+      null,
+      null
+    );
+
+    expect(body.anonymousId).toBe("user-123");
+  });
+
+  test("bodyForEventSchemaCall with rawEventProperties passes them through (no encryption in dev without key)", () => {
+    const eventName = "event name";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+    const rawEventProperties = { prop0: "hello" };
+
+    const body = networkHandler.bodyForEventSchemaCall(
+      "",
+      eventName,
+      eventProperties,
+      null,
+      null,
+      rawEventProperties
+    );
+
+    // Without a publicEncryptionKey, encryption is not triggered,
+    // so eventProperties should be the plain schema (not encrypted)
+    expect(body.eventProperties).toEqual(eventProperties);
+    expect(body.type).toBe("event");
+    expect(body.eventName).toBe(eventName);
+  });
+
+  test("base body includes publicEncryptionKey when handler is constructed with one", () => {
+    const handlerWithKey = new AvoNetworkCallsHandler(
+      apiKey,
+      env,
+      "",
+      version,
+      inspectorVersion,
+      "test-public-key-abc"
+    );
+
+    const eventName = "event name";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+
+    const body = handlerWithKey.bodyForEventSchemaCall(
+      "",
+      eventName,
+      eventProperties,
+      null,
+      null
+    );
+
+    expect(body.publicEncryptionKey).toBe("test-public-key-abc");
+  });
+
+  test("base body does not include publicEncryptionKey when handler is constructed without one", () => {
+    const eventName = "event name";
+    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
+
+    const body = networkHandler.bodyForEventSchemaCall(
+      "",
+      eventName,
+      eventProperties,
+      null,
+      null
+    );
+
+    expect(body.publicEncryptionKey).toBeUndefined();
+  });
 });

package/src/__tests__/TestNetworkCallsHandlerPublic.ts

@@ -20,7 +20,6 @@ describe("AvoNetworkCallsHandler", () => {
   };
 
   const happyPathInspectorCall = () => {
-    inspector.avoNetworkCallsHandler["samplingRate"] = 0.1;
     return Promise.resolve();
   };
 
@@ -44,13 +43,14 @@ describe("AvoNetworkCallsHandler", () => {
     inspector.avoDeduplicator._clearEvents();
   });
 
-  test("handleTrackSchema is called on trackSchemaFromEvent", async () => {
+  test("trackSchemaFromEvent sends only event call (no sessionStarted)", async () => {
     await inspector.trackSchemaFromEvent(eventName, properties);
 
-    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
+    // Should be called once (event only, no sessionStarted)
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
     expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
       expect.objectContaining({
-        type: "sessionStarted",
+        type: "event",
         apiKey: apiKey,
         appName: appName,
         appVersion: version,
@@ -58,32 +58,49 @@ describe("AvoNetworkCallsHandler", () => {
         env: env,
         libPlatform: "node",
         messageId: expect.anything(),
-        trackingId: "",
+        anonymousId: "",
         createdAt: expect.any(String),
-        sessionId: expect.anything(),
         samplingRate: 1,
       }),
-    ]
-    );
+    ]);
+  });
+
+  test("trackSchemaFromEvent with streamId sets anonymousId to streamId", async () => {
+    await inspector.trackSchemaFromEvent(eventName, properties, "user-stream-123");
+
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
     expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
       expect.objectContaining({
         type: "event",
-        apiKey: apiKey,
-        appName: appName,
-        appVersion: version,
-        libVersion: expect.anything(),
-        env: env,
-        libPlatform: "node",
-        messageId: expect.anything(),
-        trackingId: "",
-        createdAt: expect.anything(),
-        sessionId: expect.anything(),
-        samplingRate: 0.1,
+        anonymousId: "user-stream-123",
       }),
     ]);
   });
 
-  test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", async () => {
+  test("trackSchemaFromEvent without streamId sets anonymousId to empty string", async () => {
+    await inspector.trackSchemaFromEvent(eventName, properties);
+
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
+      expect.objectContaining({
+        anonymousId: "",
+      }),
+    ]);
+  });
+
+  test("trackSchemaFromEvent with streamId containing ':' logs warning", async () => {
+    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+    await inspector.trackSchemaFromEvent(eventName, properties, "invalid:stream");
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "[Avo Inspector] Warning: streamId contains ':' which is not supported"
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+
+  test("_avoFunctionTrackSchemaFromEvent sends only event call (no sessionStarted)", async () => {
     const eventId = "testId";
     const eventHash = "testHash";
 
@@ -95,24 +112,8 @@ describe("AvoNetworkCallsHandler", () => {
       eventHash
     );
 
-    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
-    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toBeCalledWith([
-      expect.objectContaining({
-        type: "sessionStarted",
-        apiKey: apiKey,
-        appName: appName,
-        appVersion: version,
-        libVersion: expect.anything(),
-        env: env,
-        libPlatform: "node",
-        messageId: expect.anything(),
-        trackingId: "",
-        createdAt: expect.anything(),
-        sessionId: expect.anything(),
-        samplingRate: 0.1,
-      })
-    ]
-    );
+    // Should be called once (event only, no sessionStarted)
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
     expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
       expect.objectContaining({
         type: "event",
@@ -123,20 +124,85 @@ describe("AvoNetworkCallsHandler", () => {
         env: env,
         libPlatform: "node",
         messageId: expect.anything(),
-        trackingId: "",
-        createdAt: expect.anything(),
-        sessionId: expect.anything(),
-        samplingRate: 0.1,
+        anonymousId: "",
+        createdAt: expect.any(String),
       }),
     ]);
   });
 
   test("an error is logged if event schema call fails and AvoInspector.shouldLog is true", async () => {
-    inspectorCallSpy.mockImplementationOnce(happyPathInspectorCall);
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
     inspectorCallSpy.mockRejectedValueOnce('Network error');
 
     await inspector.trackSchemaFromEvent(eventName, properties);
 
-    expect(consoleLogSpy).toHaveBeenCalledWith('Avo Inspector: schema sending failed: Network error.');
+    expect(consoleErrorSpy).toHaveBeenCalledWith('Avo Inspector: schema sending failed: Network error.');
+    consoleErrorSpy.mockRestore();
+  });
+
+  test("_avoFunctionTrackSchemaFromEvent passes empty string as anonymousId", async () => {
+    const eventId = "testId";
+    const eventHash = "testHash";
+
+    // @ts-ignore
+    await inspector._avoFunctionTrackSchemaFromEvent(
+      eventName,
+      properties,
+      eventId,
+      eventHash
+    );
+
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
+      expect.objectContaining({
+        anonymousId: "",
+      }),
+    ]);
+  });
+
+  test("trackSchemaFromEvent with streamId containing ':' still sends the event", async () => {
+    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+    await inspector.trackSchemaFromEvent(eventName, properties, "bad:stream");
+
+    // Warning is logged
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "[Avo Inspector] Warning: streamId contains ':' which is not supported"
+    );
+
+    // Event is still sent despite the warning
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
+      expect.objectContaining({
+        type: "event",
+        anonymousId: "bad:stream",
+      }),
+    ]);
+
+    consoleWarnSpy.mockRestore();
+  });
+
+  test("same event with different streamIds is not deduplicated", async () => {
+    await inspector.trackSchemaFromEvent(eventName, properties, "stream-a");
+    await inspector.trackSchemaFromEvent(eventName, properties, "stream-b");
+
+    expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
+  });
+
+  test("trackSchemaFromEvent rejection contains the expected error string", async () => {
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    // Force the catch block in trackSchemaFromEvent by making extractSchema throw
+    jest.spyOn(inspector, "extractSchema").mockImplementation(() => {
+      throw new Error("test explosion");
+    });
+
+    await expect(
+      inspector.trackSchemaFromEvent(eventName, properties)
+    ).rejects.toBe(
+      "Avo Inspector: something went wrong. Please report to support@avo.app."
+    );
+
+    consoleErrorSpy.mockRestore();
+    (inspector.extractSchema as jest.Mock).mockRestore();
   });
 });