node-avo-inspector 1.2.0-alpha.1 → 2.0.0-beta.1

package/.claude/worktrees/release-1.1.1/src/__tests__/TestEventValidator.ts

@@ -1,231 +0,0 @@
-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" },
-      ];
-
-      const results = validator.validate(spec, eventProperties, "evt-4");
-      const urlResult = results.find((r: PropertyValidationResult) => r.propertyName === "url");
-      // Type 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/.claude/worktrees/release-1.1.1/src/__tests__/TestNetworkCallsHandler.ts

@@ -1,179 +0,0 @@
-import { AvoGuid } from "../AvoGuid";
-import { AvoNetworkCallsHandler, BaseBody } from "../AvoNetworkCallsHandler";
-
-import {
-  defaultOptions,
-  mockedReturns,
-} from "./constants";
-
-const inspectorVersion = process.env.npm_package_version || "";
-
-describe("NetworkCallsHandler", () => {
-  const { apiKey, env, version } = defaultOptions;
-  const appName = "";
-
-  let networkHandler: AvoNetworkCallsHandler;
-  let baseBody: BaseBody;
-
-  const now = new Date();
-
-  beforeAll(() => {
-    // @ts-ignore
-    jest.spyOn(global, "Date").mockImplementation(() => now);
-
-    jest
-      .spyOn(AvoGuid as any, "newGuid")
-      .mockImplementation(() => mockedReturns.GUID);
-
-    networkHandler = new AvoNetworkCallsHandler(
-      apiKey,
-      env,
-      "",
-      version,
-      inspectorVersion
-    );
-
-    baseBody = {
-      apiKey,
-      appName,
-      appVersion: version,
-      libVersion: inspectorVersion,
-      env,
-      libPlatform: "node",
-      messageId: mockedReturns.GUID,
-      anonymousId: "",
-      createdAt: new Date().toISOString(),
-      samplingRate: 1.0,
-    };
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  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(
-      "",
-      eventName,
-      eventProperties,
-      null,
-      null
-    );
-
-    expect(body).toEqual({
-      ...baseBody,
-      anonymousId: "",
-      type: "event",
-      eventName,
-      eventProperties,
-      avoFunction: false,
-      eventId: null,
-      eventHash: null,
-    });
-  });
-
-  test("bodyForEventSchemaCall returns base body + event schema used for event sending from Codegen", () => {
-    const eventName = "event name";
-    const eventId = "event id";
-    const eventHash = "event hash";
-    const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-
-    const body = networkHandler.bodyForEventSchemaCall(
-      "",
-      eventName,
-      eventProperties,
-      eventId,
-      eventHash
-    );
-
-    expect(body).toEqual({
-      ...baseBody,
-      anonymousId: "",
-      type: "event",
-      eventName,
-      eventProperties,
-      avoFunction: true,
-      eventId,
-      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/.claude/worktrees/release-1.1.1/src/__tests__/TestNetworkCallsHandlerPublic.ts

@@ -1,208 +0,0 @@
-import { AvoInspector } from "../AvoInspector";
-import { AvoNetworkCallsHandler } from "../AvoNetworkCallsHandler";
-
-import { defaultOptions } from "./constants";
-
-describe("AvoNetworkCallsHandler", () => {
-  let inspectorCallSpy: jest.SpyInstance<any, unknown[]>;
-  let consoleLogSpy: jest.SpyInstance<any, unknown[]>;
-
-  let inspector: AvoInspector;
-
-  const { apiKey, env, version, appName } = defaultOptions;
-
-  const eventName = "event name";
-  const properties = {
-    prop0: "",
-    prop2: false,
-    prop3: 0,
-    prop4: 0.0,
-  };
-
-  const happyPathInspectorCall = () => {
-    return Promise.resolve();
-  };
-
-  beforeAll(() => {
-    inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(true);
-
-    inspectorCallSpy = jest
-      .spyOn(AvoNetworkCallsHandler.prototype as any, "callInspectorWithBatchBody");
-
-    consoleLogSpy = jest.spyOn(console, "log").mockImplementation(() => {});
-  });
-
-  beforeEach(() => {
-    inspectorCallSpy.mockImplementation(happyPathInspectorCall);
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks();
-    // @ts-ignore
-    inspector.avoDeduplicator._clearEvents();
-  });
-
-  test("trackSchemaFromEvent sends only event call (no sessionStarted)", async () => {
-    await inspector.trackSchemaFromEvent(eventName, properties);
-
-    // Should be called once (event only, no sessionStarted)
-    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(),
-        anonymousId: "",
-        createdAt: expect.any(String),
-        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",
-        anonymousId: "user-stream-123",
-      }),
-    ]);
-  });
-
-  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";
-
-    // @ts-ignore
-    await inspector._avoFunctionTrackSchemaFromEvent(
-      eventName,
-      properties,
-      eventId,
-      eventHash
-    );
-
-    // Should be called once (event only, no sessionStarted)
-    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(),
-        anonymousId: "",
-        createdAt: expect.any(String),
-      }),
-    ]);
-  });
-
-  test("an error is logged if event schema call fails and AvoInspector.shouldLog is true", async () => {
-    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-    inspectorCallSpy.mockRejectedValueOnce('Network error');
-
-    await inspector.trackSchemaFromEvent(eventName, properties);
-
-    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();
-  });
-});