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

package/.claude/worktrees/release-1.1.1/src/AvoSchemaParser.ts

@@ -1,115 +0,0 @@
-let isArray = (obj: any): boolean => {
-  return Object.prototype.toString.call(obj) === "[object Array]";
-};
-
-export class AvoSchemaParser {
-  static extractSchema(eventProperties: {
-    [propName: string]: any;
-  }): Array<{
-    propertyName: string;
-    propertyType: string;
-    children?: any;
-  }> {
-    if (eventProperties === null || eventProperties === undefined) {
-      return [];
-    }
-
-    let mapping = (object: any) => {
-      if (isArray(object)) {
-        let list = object.map((x: any) => {
-          return mapping(x);
-        });
-        return this.removeDuplicates(list);
-      } else if (typeof object === "object") {
-        let mappedResult: any = [];
-        for (var key in object) {
-          if (object.hasOwnProperty(key)) {
-            let val = object[key];
-
-            let mappedEntry: {
-              propertyName: string;
-              propertyType: string;
-              children?: any;
-            } = {
-              propertyName: key,
-              propertyType: this.getPropValueType(val),
-            };
-
-            if (typeof val === "object" && val != null) {
-              mappedEntry["children"] = mapping(val);
-            }
-
-            mappedResult.push(mappedEntry);
-          }
-        }
-
-        return mappedResult;
-      } else {
-        return this.getPropValueType(object);
-      }
-    };
-
-    var mappedEventProps = mapping(eventProperties);
-
-    return mappedEventProps;
-  }
-
-  private static removeDuplicates(array: Array<any>): Array<any> {
-    // XXX TODO fix any types
-    var primitives: any = { boolean: {}, number: {}, string: {} };
-    var objects: Array<any> = [];
-
-    return array.filter((item: any) => {
-      var type: string = typeof item;
-      if (type in primitives) {
-        return primitives[type].hasOwnProperty(item)
-          ? false
-          : (primitives[type][item] = true);
-      } else {
-        return objects.indexOf(item) >= 0 ? false : objects.push(item);
-      }
-    });
-  }
-
-
-  private static getBasicPropType(propValue: any): string {
-    let propType = typeof propValue;
-    if (propValue == null) {
-      return "null";
-    } else if (propType === "string") {
-      return "string";
-    } else if (propType === "number" || propType === "bigint") {
-      if ((propValue + "").indexOf(".") >= 0) {
-        return "float";
-      } else {
-        return "int";
-      }
-    } else if (propType === "boolean") {
-      return "boolean";
-    } else if (propType === "object") {
-      return "object"
-  }
-  else {
-  return "unknown";
-  }
-}
-
-  private static getPropValueType(propValue: any): string {
-    if (isArray(propValue)){
-
-      //we now know that propValue is an array. get first element in propValue array
-      let propElement = propValue[0];
-
-      if (propElement == null) {
-        return "list(string)"; // Default to list(string) if the list is empty.
-      }
-      else {
-      let propElementType = this.getBasicPropType(propElement);
-      return `list(${propElementType})`
-      }
-    }
-    else {
-      return this.getBasicPropType(propValue);
-    }
-  }
-}

package/.claude/worktrees/release-1.1.1/src/AvoStreamId.ts

@@ -1,16 +0,0 @@
-export class AvoStreamId {
-  private _streamId: string;
-
-  constructor(streamId?: string) {
-    this._streamId = streamId ?? "";
-    if (this._streamId.includes(":")) {
-      console.warn(
-        "[Avo Inspector] Warning: streamId contains ':' which is not supported"
-      );
-    }
-  }
-
-  get streamId(): string {
-    return this._streamId;
-  }
-}

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

@@ -1,515 +0,0 @@
-import * as crypto from "crypto";
-import { AvoEncryption } from "../AvoEncryption";
-import { AvoNetworkCallsHandler } from "../AvoNetworkCallsHandler";
-import { AvoInspectorEnv } from "../AvoInspectorEnv";
-import { AvoGuid } from "../AvoGuid";
-import { mockedReturns } from "./constants";
-
-// Generate a test key pair for encryption tests
-function generateTestKeyPair() {
-  const ecdh = crypto.createECDH("prime256v1");
-  ecdh.generateKeys();
-  return {
-    publicKey: ecdh.getPublicKey("hex"),
-    privateKey: ecdh.getPrivateKey(),
-    ecdh,
-  };
-}
-
-function parseWireFormat(encryptedBase64: string) {
-  const wire = Buffer.from(encryptedBase64, "base64");
-  return {
-    version: wire[0],
-    ephemeralPubKey: wire.subarray(1, 66),
-    iv: wire.subarray(66, 82),
-    authTag: wire.subarray(82, 98),
-    ciphertext: wire.subarray(98),
-    wire,
-  };
-}
-
-describe("AvoEncryption", () => {
-  describe("shouldEncrypt", () => {
-    const dummyHexKey = "deadbeef";
-
-    test("dev + key => true", () => {
-      expect(AvoEncryption.shouldEncrypt(AvoInspectorEnv.Dev, dummyHexKey)).toBe(true);
-    });
-
-    test("staging + key => true", () => {
-      expect(AvoEncryption.shouldEncrypt(AvoInspectorEnv.Staging, dummyHexKey)).toBe(true);
-    });
-
-    test("prod + key => false", () => {
-      expect(AvoEncryption.shouldEncrypt(AvoInspectorEnv.Prod, dummyHexKey)).toBe(false);
-    });
-
-    test("dev + null => false", () => {
-      expect(AvoEncryption.shouldEncrypt(AvoInspectorEnv.Dev, undefined)).toBe(false);
-    });
-
-    test("dev + empty string => false", () => {
-      expect(AvoEncryption.shouldEncrypt(AvoInspectorEnv.Dev, "")).toBe(false);
-    });
-  });
-
-  describe("wire format", () => {
-    const testKeyPair = generateTestKeyPair();
-
-    test("base64Decode(output).length >= 99", () => {
-      const encrypted = AvoEncryption.encryptValue("hello", testKeyPair.publicKey);
-      expect(encrypted).not.toBeNull();
-      const decoded = Buffer.from(encrypted!, "base64");
-      // 1 (version) + 65 (ephemeral pubkey) + 16 (IV) + 16 (auth tag) + ciphertext >= 1
-      expect(decoded.length).toBeGreaterThanOrEqual(99);
-    });
-
-    test("output[0] == 0x00 (version byte)", () => {
-      const encrypted = AvoEncryption.encryptValue("hello", testKeyPair.publicKey);
-      const decoded = Buffer.from(encrypted!, "base64");
-      expect(decoded[0]).toBe(0x00);
-    });
-
-    test("output[1] == 0x04 (uncompressed pubkey marker)", () => {
-      const encrypted = AvoEncryption.encryptValue("hello", testKeyPair.publicKey);
-      const decoded = Buffer.from(encrypted!, "base64");
-      expect(decoded[1]).toBe(0x04);
-    });
-
-    test("ephemeral public key is 65 bytes (uncompressed)", () => {
-      const encrypted = AvoEncryption.encryptValue("test data", testKeyPair.publicKey);
-      const decoded = Buffer.from(encrypted!, "base64");
-      // bytes 1..65 are the ephemeral public key
-      const ephemeralPubKey = decoded.subarray(1, 66);
-      expect(ephemeralPubKey.length).toBe(65);
-      expect(ephemeralPubKey[0]).toBe(0x04); // uncompressed marker
-    });
-  });
-
-  describe("round-trip encrypt/decrypt", () => {
-    test("can decrypt back to original plaintext", () => {
-      const ecdh = crypto.createECDH("prime256v1");
-      ecdh.generateKeys();
-      const recipientPubKeyHex = ecdh.getPublicKey("hex");
-
-      const plaintext = "Hello, encryption!";
-      const encrypted = AvoEncryption.encryptValue(plaintext, recipientPubKeyHex);
-      expect(encrypted).not.toBeNull();
-
-      // Decrypt: parse wire format
-      const { version, ephemeralPubKey, iv, authTag, ciphertext } = parseWireFormat(encrypted!);
-      expect(version).toBe(0x00);
-
-      // Compute shared secret the same way
-      const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-      const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-
-      const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-        authTagLength: 16,
-      });
-      decipher.setAuthTag(authTag);
-      let decrypted = decipher.update(ciphertext);
-      decrypted = Buffer.concat([decrypted, decipher.final()]);
-
-      expect(decrypted.toString("utf8")).toBe(plaintext);
-    });
-
-    test("different encryptions of same value produce different ciphertext", () => {
-      const ecdh = crypto.createECDH("prime256v1");
-      ecdh.generateKeys();
-      const pubKey = ecdh.getPublicKey("hex");
-
-      const enc1 = AvoEncryption.encryptValue("same", pubKey);
-      const enc2 = AvoEncryption.encryptValue("same", pubKey);
-      // Ephemeral keys differ each time, so output differs
-      expect(enc1).not.toBe(enc2);
-    });
-  });
-
-  describe("encryption failure handling", () => {
-    test("returns null and warns on invalid key", () => {
-      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-      const result = AvoEncryption.encryptValue("hello", "not-a-valid-hex-key");
-      expect(result).toBeNull();
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("[Avo Inspector] Warning:")
-      );
-      warnSpy.mockRestore();
-    });
-  });
-
-  describe("isListType", () => {
-    test("detects list types", () => {
-      expect(AvoEncryption.isListType("list(string)")).toBe(true);
-      expect(AvoEncryption.isListType("list(int)")).toBe(true);
-      expect(AvoEncryption.isListType("list(object)")).toBe(true);
-    });
-
-    test("non-list types return false", () => {
-      expect(AvoEncryption.isListType("string")).toBe(false);
-      expect(AvoEncryption.isListType("int")).toBe(false);
-      expect(AvoEncryption.isListType("object")).toBe(false);
-    });
-  });
-});
-
-describe("AvoNetworkCallsHandler encryption integration", () => {
-  const inspectorVersion = process.env.npm_package_version || "";
-
-  beforeEach(() => {
-    const now = new Date();
-    // @ts-ignore
-    jest.spyOn(global, "Date").mockImplementation(() => now);
-    jest
-      .spyOn(AvoGuid as any, "newGuid")
-      .mockImplementation(() => mockedReturns.GUID);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  test("publicEncryptionKey included in base body when non-null and non-empty", () => {
-    const pubKey = "deadbeef";
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "prop1", propertyType: "string" }],
-      null,
-      null
-    );
-
-    expect((body as any).publicEncryptionKey).toBe(pubKey);
-  });
-
-  test("publicEncryptionKey NOT included in base body when null", () => {
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      undefined
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "prop1", propertyType: "string" }],
-      null,
-      null
-    );
-
-    expect((body as any).publicEncryptionKey).toBeUndefined();
-  });
-
-  test("publicEncryptionKey NOT included in base body when empty string", () => {
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      ""
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "prop1", propertyType: "string" }],
-      null,
-      null
-    );
-
-    expect((body as any).publicEncryptionKey).toBeUndefined();
-  });
-
-  test("dev env with key: properties are encrypted with encryptedPropertyValue", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "username", propertyType: "string" }],
-      null,
-      null,
-      { username: "alice" }
-    );
-
-    // Should have encryptedPropertyValue alongside propertyType
-    expect(body.eventProperties.length).toBe(1);
-    expect(body.eventProperties[0].propertyName).toBe("username");
-    expect((body.eventProperties[0] as any).encryptedPropertyValue).toBeDefined();
-    expect((body.eventProperties[0] as any).propertyType).toBe("string");
-  });
-
-  test("prod env: no encryptedPropertyValue, propertyType kept as-is", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Prod,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "username", propertyType: "string" }],
-      null,
-      null
-    );
-
-    expect(body.eventProperties.length).toBe(1);
-    expect((body.eventProperties[0] as any).propertyType).toBe("string");
-    expect((body.eventProperties[0] as any).encryptedPropertyValue).toBeUndefined();
-  });
-
-  test("list-type properties are omitted entirely when encryption is active", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [
-        { propertyName: "name", propertyType: "string" },
-        { propertyName: "tags", propertyType: "list(string)" },
-        { propertyName: "scores", propertyType: "list(int)" },
-      ],
-      null,
-      null,
-      { name: "Alice", tags: ["a", "b"], scores: [1, 2] }
-    );
-
-    // List types should be omitted
-    expect(body.eventProperties.length).toBe(1);
-    expect(body.eventProperties[0].propertyName).toBe("name");
-  });
-
-  test("encryption failure: property is omitted, warning logged", () => {
-    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      "invalid-key-that-will-fail"
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "prop1", propertyType: "string" }],
-      null,
-      null,
-      { prop1: "hello" }
-    );
-
-    // Property should be omitted on failure
-    expect(body.eventProperties.length).toBe(0);
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("[Avo Inspector] Warning:")
-    );
-    warnSpy.mockRestore();
-  });
-
-  test("non-string value (number) is JSON.stringify'd before encryption", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "count", propertyType: "int" }],
-      null,
-      null,
-      { count: 42 }
-    );
-
-    expect(body.eventProperties.length).toBe(1);
-    const encryptedValue = (body.eventProperties[0] as any).encryptedPropertyValue;
-    expect(encryptedValue).toBeDefined();
-
-    // Decrypt and verify the value is the JSON-stringified number "42"
-    const { ephemeralPubKey, iv, authTag, ciphertext } = parseWireFormat(encryptedValue);
-
-    const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-    const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-    const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-      authTagLength: 16,
-    });
-    decipher.setAuthTag(authTag);
-    let decrypted = decipher.update(ciphertext);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    expect(decrypted.toString("utf8")).toBe("42");
-  });
-
-  test("missing property in rawEventProperties encrypts 'null' instead of crashing", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    // Schema says "missing_prop" exists, but rawEventProperties does NOT have it
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "missing_prop", propertyType: "string" }],
-      null,
-      null,
-      { other_prop: "value" }
-    );
-
-    expect(body.eventProperties.length).toBe(1);
-    const encryptedValue = (body.eventProperties[0] as any).encryptedPropertyValue;
-    expect(encryptedValue).toBeDefined();
-
-    // Decrypt and verify the value is "null"
-    const { ephemeralPubKey, iv, authTag, ciphertext } = parseWireFormat(encryptedValue);
-
-    const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-    const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-    const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-      authTagLength: 16,
-    });
-    decipher.setAuthTag(authTag);
-    let decrypted = decipher.update(ciphertext);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    expect(decrypted.toString("utf8")).toBe("null");
-  });
-
-  test("children are preserved in encrypted property output", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const children = [
-      { propertyName: "street", propertyType: "string" },
-      { propertyName: "zip", propertyType: "int" },
-    ];
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "address", propertyType: "object", children }],
-      null,
-      null,
-      { address: { street: "123 Main St", zip: 12345 } }
-    );
-
-    expect(body.eventProperties.length).toBe(1);
-    const prop = body.eventProperties[0] as any;
-    expect(prop.propertyName).toBe("address");
-    expect(prop.encryptedPropertyValue).toBeDefined();
-    expect(prop.children).toEqual(children);
-  });
-
-  test("cross-SDK interop: encrypted wire format structure is correct", () => {
-    const ecdh = crypto.createECDH("prime256v1");
-    ecdh.generateKeys();
-    const pubKey = ecdh.getPublicKey("hex");
-
-    const handler = new AvoNetworkCallsHandler(
-      "api-key",
-      AvoInspectorEnv.Dev,
-      "app",
-      "1.0",
-      inspectorVersion,
-      pubKey
-    );
-
-    const body = handler.bodyForEventSchemaCall(
-      "anon-id",
-      "test-event",
-      [{ propertyName: "email", propertyType: "string" }],
-      null,
-      null,
-      { email: "user@example.com" }
-    );
-
-    const encryptedValue = (body.eventProperties[0] as any).encryptedPropertyValue;
-    expect(encryptedValue).toBeDefined();
-
-    const { version, ephemeralPubKey, iv, authTag, ciphertext, wire } = parseWireFormat(encryptedValue);
-    // Verify wire format: [0x00][65-byte ephemeral pubkey][16-byte IV][16-byte auth tag][ciphertext]
-    expect(wire.length).toBeGreaterThanOrEqual(99);
-    expect(version).toBe(0x00); // version
-    expect(ephemeralPubKey[0]).toBe(0x04); // uncompressed pubkey marker
-
-    // Verify we can decrypt it
-    const sharedSecret = ecdh.computeSecret(ephemeralPubKey);
-    const aesKey = crypto.createHash("sha256").update(sharedSecret).digest();
-    const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv, {
-      authTagLength: 16,
-    });
-    decipher.setAuthTag(authTag);
-    let decrypted = decipher.update(ciphertext);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    expect(decrypted.toString("utf8")).toBe('"user@example.com"');
-  });
-});