node-avo-inspector 1.1.1 → 1.2.0-alpha.1

package/dist/AvoNetworkCallsHandler.d.ts

@@ -1,3 +1,4 @@
+import { EventSpecMetadata, PropertyValidationResult } from "./eventSpec/AvoEventSpecFetchTypes";
 export interface BaseBody {
     apiKey: string;
     appName: string;
@@ -7,25 +8,39 @@ export interface BaseBody {
     libPlatform: "node";
     messageId: string;
     trackingId: string;
-    createdAt: string;
     sessionId: string;
+    anonymousId: string;
+    createdAt: string;
     samplingRate: number;
+    publicEncryptionKey?: string;
+}
+export interface EventPropertyEncrypted {
+    propertyName: string;
+    propertyType: string;
+    encryptedPropertyValue: string;
+    children?: any;
 }
-export interface SessionStartedBody extends BaseBody {
-    type: "sessionStarted";
+export interface EventPropertyPlain {
+    propertyName: string;
+    propertyType: string;
+    children?: any;
 }
+export interface EventPropertyValidation {
+    failedEventIds?: string[];
+    passedEventIds?: string[];
+}
+export type EventProperty = (EventPropertyEncrypted | EventPropertyPlain) & EventPropertyValidation;
 export interface EventSchemaBody extends BaseBody {
     type: "event";
     eventName: string;
-    eventProperties: Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>;
+    eventProperties: Array<EventProperty>;
     avoFunction: boolean;
     eventId: string | null;
     eventHash: string | null;
+    streamId?: string;
+    eventSpecMetadata?: EventSpecMetadata;
 }
+export type InspectorBody = EventSchemaBody;
 export declare class AvoNetworkCallsHandler {
     private apiKey;
     private envName;
@@ -33,14 +48,25 @@ export declare class AvoNetworkCallsHandler {
     private appVersion;
     private libVersion;
     private samplingRate;
+    private publicEncryptionKey?;
     private static trackingEndpoint;
-    constructor(apiKey: string, envName: string, appName: string, appVersion: string, libVersion: string);
-    callInspectorWithBatchBody(inEvents: Array<SessionStartedBody | EventSchemaBody>): Promise<void>;
-    bodyForSessionStartedCall(sessionId: string): SessionStartedBody;
-    bodyForEventSchemaCall(sessionId: string, eventName: string, eventProperties: Array<{
+    constructor(apiKey: string, envName: string, appName: string, appVersion: string, libVersion: string, publicEncryptionKey?: string);
+    callInspectorWithBatchBody(inEvents: Array<InspectorBody>): Promise<void>;
+    bodyForEventSchemaCall(anonymousId: string, eventName: string, eventProperties: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>, eventId: string | null, eventHash: string | null, rawEventProperties?: {
+        [propName: string]: any;
+    }): EventSchemaBody;
+    buildEventProperties(eventProperties: Array<{
         propertyName: string;
         propertyType: string;
         children?: any;
-    }>, eventId: string | null, eventHash: string | null): EventSchemaBody;
+    }>, rawEventProperties?: {
+        [propName: string]: any;
+    }): Array<EventProperty>;
+    bodyForValidatedEventSchemaCall(anonymousId: string, eventName: string, eventProperties: Array<EventProperty>, eventId: string | null, eventHash: string | null, eventSpecMetadata: EventSpecMetadata, propertyResults: PropertyValidationResult[]): EventSchemaBody;
+    private encryptProperties;
     private createBaseCallBody;
 }

package/dist/AvoNetworkCallsHandler.js

@@ -3,15 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoNetworkCallsHandler = void 0;
 const AvoGuid_1 = require("./AvoGuid");
 const AvoInspector_1 = require("./AvoInspector");
+const AvoEncryption_1 = require("./AvoEncryption");
 const https_1 = require("https");
 class AvoNetworkCallsHandler {
-    constructor(apiKey, envName, appName, appVersion, libVersion) {
+    constructor(apiKey, envName, appName, appVersion, libVersion, publicEncryptionKey) {
         this.samplingRate = 1.0;
         this.apiKey = apiKey;
         this.envName = envName;
         this.appName = appName;
         this.appVersion = appVersion;
         this.libVersion = libVersion;
+        this.publicEncryptionKey = publicEncryptionKey;
     }
     callInspectorWithBatchBody(inEvents) {
         const events = inEvents.filter((x) => x != null);
@@ -26,64 +28,87 @@ class AvoNetworkCallsHandler {
         }
         if (AvoInspector_1.AvoInspector.shouldLog) {
             events.forEach(function (event) {
-                if (event.type === "sessionStarted") {
-                    console.log("Avo Inspector: sending session started event.");
-                }
-                else if (event.type === "event") {
-                    let schemaEvent = event;
-                    console.log("Avo Inspector: sending event " +
-                        schemaEvent.eventName +
-                        " with schema " +
-                        JSON.stringify(schemaEvent.eventProperties));
-                }
+                const eventProps = event.eventProperties
+                    .map(p => '\t"' + p.propertyName + '": "' + p.propertyType + '"')
+                    .join(";\n");
+                const validated = event.eventSpecMetadata ? " (validated)" : "";
+                console.log("Avo Inspector: Sending event " +
+                    event.eventName + validated +
+                    " with schema {\n" + eventProps + "\n}");
             });
         }
-        return new Promise(function (resolve, reject) {
+        return new Promise((resolve, reject) => {
             const data = JSON.stringify(events);
-            var options = {
+            const options = {
                 hostname: "api.avo.app",
                 port: 443,
                 path: AvoNetworkCallsHandler.trackingEndpoint,
                 method: "POST",
                 headers: {
-                    "Content-Type": "text/plain",
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
                     "Content-Length": Buffer.byteLength(data),
                 },
             };
-            var req = (0, https_1.request)(options, (res) => {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.log("Avo Inspector: [network] POST https://" + options.hostname + options.path);
+                console.log("Avo Inspector: [network] Request body (" + Buffer.byteLength(data) + " bytes)");
+            }
+            const req = (0, https_1.request)(options, (res) => {
+                if (AvoInspector_1.AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: [network] Response status: " + res.statusCode + " " + res.statusMessage);
+                }
                 const chunks = [];
                 res.on("data", (data) => chunks.push(data));
                 res.on("end", () => {
-                    try {
-                        // @ts-ignore
-                        const data = JSON.parse(Buffer.concat(chunks).toString());
-                        // @ts-ignore
-                        this.samplingRate = data.samplingRate;
+                    if (res.statusCode === 200) {
+                        try {
+                            const responseBody = Buffer.concat(chunks).toString();
+                            const data = JSON.parse(responseBody);
+                            if (typeof data.samplingRate === "number" && data.samplingRate >= 0 && data.samplingRate <= 1) {
+                                this.samplingRate = data.samplingRate;
+                            }
+                        }
+                        catch (e) {
+                            if (AvoInspector_1.AvoInspector.shouldLog) {
+                                console.warn("Avo Inspector: [network] Failed to parse response JSON: " + e);
+                            }
+                        }
+                    }
+                    else if (AvoInspector_1.AvoInspector.shouldLog) {
+                        console.warn("Avo Inspector: [network] Non-200 response: " + res.statusCode);
                     }
-                    catch (e) { }
                     resolve();
                 });
             });
             req.write(data);
-            req.on("error", () => {
+            req.setTimeout(10000);
+            req.on("error", (err) => {
+                if (AvoInspector_1.AvoInspector.shouldLog) {
+                    console.error("Avo Inspector: [network] Request error: " + err);
+                }
                 reject("Request failed");
             });
             req.on("timeout", () => {
+                if (AvoInspector_1.AvoInspector.shouldLog) {
+                    console.error("Avo Inspector: [network] Request timed out after 10s");
+                }
+                req.destroy();
                 reject("Request timed out");
             });
             req.end();
         });
     }
-    bodyForSessionStartedCall(sessionId) {
-        let sessionBody = this.createBaseCallBody(sessionId);
-        sessionBody.type = "sessionStarted";
-        return sessionBody;
-    }
-    bodyForEventSchemaCall(sessionId, eventName, eventProperties, eventId, eventHash) {
-        let eventSchemaBody = this.createBaseCallBody(sessionId);
+    bodyForEventSchemaCall(anonymousId, eventName, eventProperties, eventId, eventHash, rawEventProperties) {
+        let eventSchemaBody = this.createBaseCallBody(anonymousId);
         eventSchemaBody.type = "event";
         eventSchemaBody.eventName = eventName;
-        eventSchemaBody.eventProperties = eventProperties;
+        if (AvoEncryption_1.AvoEncryption.shouldEncrypt(this.envName, this.publicEncryptionKey) && rawEventProperties) {
+            eventSchemaBody.eventProperties = this.encryptProperties(eventProperties, rawEventProperties);
+        }
+        else {
+            eventSchemaBody.eventProperties = eventProperties;
+        }
         if (eventId != null) {
             eventSchemaBody.avoFunction = true;
             eventSchemaBody.eventId = eventId;
@@ -96,8 +121,72 @@ class AvoNetworkCallsHandler {
         }
         return eventSchemaBody;
     }
-    createBaseCallBody(sessionId) {
-        return {
+    buildEventProperties(eventProperties, rawEventProperties) {
+        if (AvoEncryption_1.AvoEncryption.shouldEncrypt(this.envName, this.publicEncryptionKey) && rawEventProperties) {
+            return this.encryptProperties(eventProperties, rawEventProperties);
+        }
+        return eventProperties;
+    }
+    bodyForValidatedEventSchemaCall(anonymousId, eventName, eventProperties, eventId, eventHash, eventSpecMetadata, propertyResults) {
+        // Build a map of validation results by property name
+        const validationMap = new Map();
+        for (const result of propertyResults) {
+            validationMap.set(result.propertyName, result);
+        }
+        // Merge validation results into eventProperties (matching Android)
+        const mergedProperties = eventProperties.map((prop) => {
+            const validation = validationMap.get(prop.propertyName);
+            if (validation) {
+                const merged = Object.assign({}, prop);
+                if (validation.failedEventIds.length > 0) {
+                    merged.failedEventIds = validation.failedEventIds;
+                }
+                if (validation.passedEventIds.length > 0) {
+                    merged.passedEventIds = validation.passedEventIds;
+                }
+                return merged;
+            }
+            return prop;
+        });
+        let body = this.createBaseCallBody(anonymousId);
+        body.type = "event";
+        body.eventName = eventName;
+        body.eventProperties = mergedProperties;
+        body.streamId = anonymousId;
+        body.eventSpecMetadata = eventSpecMetadata;
+        if (eventId != null) {
+            body.avoFunction = true;
+            body.eventId = eventId;
+            body.eventHash = eventHash;
+        }
+        else {
+            body.avoFunction = false;
+            body.eventId = null;
+            body.eventHash = null;
+        }
+        return body;
+    }
+    encryptProperties(properties, rawEventProperties) {
+        var _a;
+        const result = [];
+        for (const prop of properties) {
+            // List-type properties: omit entirely
+            if (AvoEncryption_1.AvoEncryption.isListType(prop.propertyType)) {
+                continue;
+            }
+            const rawValue = rawEventProperties[prop.propertyName];
+            const jsonValue = (_a = JSON.stringify(rawValue)) !== null && _a !== void 0 ? _a : "null";
+            const encrypted = AvoEncryption_1.AvoEncryption.encryptValue(jsonValue, this.publicEncryptionKey);
+            if (encrypted === null) {
+                // Encryption failure: omit the property (warning already logged by encryptValue)
+                continue;
+            }
+            result.push(Object.assign({ propertyName: prop.propertyName, propertyType: prop.propertyType, encryptedPropertyValue: encrypted }, (prop.children !== undefined ? { children: prop.children } : {})));
+        }
+        return result;
+    }
+    createBaseCallBody(anonymousId) {
+        const body = {
             apiKey: this.apiKey,
             appName: this.appName,
             appVersion: this.appVersion,
@@ -106,10 +195,15 @@ class AvoNetworkCallsHandler {
             libPlatform: "node",
             messageId: AvoGuid_1.AvoGuid.newGuid(),
             trackingId: "",
+            sessionId: "",
+            anonymousId: anonymousId,
             createdAt: new Date().toISOString(),
-            sessionId: sessionId,
             samplingRate: this.samplingRate,
         };
+        if (this.publicEncryptionKey && this.publicEncryptionKey.length > 0) {
+            body.publicEncryptionKey = this.publicEncryptionKey;
+        }
+        return body;
     }
 }
 exports.AvoNetworkCallsHandler = AvoNetworkCallsHandler;

package/dist/AvoStreamId.d.ts

@@ -0,0 +1,5 @@
+export declare class AvoStreamId {
+    private _streamId;
+    constructor(streamId?: string);
+    get streamId(): string;
+}

package/dist/AvoStreamId.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoStreamId = void 0;
+class AvoStreamId {
+    constructor(streamId) {
+        this._streamId = streamId !== null && streamId !== void 0 ? streamId : "";
+        if (this._streamId.includes(":")) {
+            console.warn("[Avo Inspector] Warning: streamId contains ':' which is not supported");
+        }
+    }
+    get streamId() {
+        return this._streamId;
+    }
+}
+exports.AvoStreamId = AvoStreamId;

package/dist/__tests__/TestAvoEncryption.d.ts

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

package/dist/__tests__/TestAvoEncryption.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("crypto");
+const AvoEncryption_1 = require("../AvoEncryption");
+const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
+const AvoInspectorEnv_1 = require("../AvoInspectorEnv");
+const AvoGuid_1 = require("../AvoGuid");
+const constants_1 = require("./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) {
+    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_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Dev, dummyHexKey)).toBe(true);
+        });
+        test("staging + key => true", () => {
+            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Staging, dummyHexKey)).toBe(true);
+        });
+        test("prod + key => false", () => {
+            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Prod, dummyHexKey)).toBe(false);
+        });
+        test("dev + null => false", () => {
+            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Dev, undefined)).toBe(false);
+        });
+        test("dev + empty string => false", () => {
+            expect(AvoEncryption_1.AvoEncryption.shouldEncrypt(AvoInspectorEnv_1.AvoInspectorEnv.Dev, "")).toBe(false);
+        });
+    });
+    describe("wire format", () => {
+        const testKeyPair = generateTestKeyPair();
+        test("base64Decode(output).length >= 99", () => {
+            const encrypted = AvoEncryption_1.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_1.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_1.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_1.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_1.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_1.AvoEncryption.encryptValue("same", pubKey);
+            const enc2 = AvoEncryption_1.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_1.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_1.AvoEncryption.isListType("list(string)")).toBe(true);
+            expect(AvoEncryption_1.AvoEncryption.isListType("list(int)")).toBe(true);
+            expect(AvoEncryption_1.AvoEncryption.isListType("list(object)")).toBe(true);
+        });
+        test("non-list types return false", () => {
+            expect(AvoEncryption_1.AvoEncryption.isListType("string")).toBe(false);
+            expect(AvoEncryption_1.AvoEncryption.isListType("int")).toBe(false);
+            expect(AvoEncryption_1.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_1.AvoGuid, "newGuid")
+            .mockImplementation(() => constants_1.mockedReturns.GUID);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test("publicEncryptionKey included in base body when non-null and non-empty", () => {
+        const pubKey = "deadbeef";
+        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, pubKey);
+        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null);
+        expect(body.publicEncryptionKey).toBe(pubKey);
+    });
+    test("publicEncryptionKey NOT included in base body when null", () => {
+        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, undefined);
+        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null);
+        expect(body.publicEncryptionKey).toBeUndefined();
+    });
+    test("publicEncryptionKey NOT included in base body when empty string", () => {
+        const handler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.AvoInspectorEnv.Dev, "app", "1.0", inspectorVersion, "");
+        const body = handler.bodyForEventSchemaCall("anon-id", "test-event", [{ propertyName: "prop1", propertyType: "string" }], null, null);
+        expect(body.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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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].encryptedPropertyValue).toBeDefined();
+        expect(body.eventProperties[0].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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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].propertyType).toBe("string");
+        expect(body.eventProperties[0].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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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].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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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].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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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];
+        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_1.AvoNetworkCallsHandler("api-key", AvoInspectorEnv_1.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].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"');
+    });
+});

package/dist/__tests__/TestAvoEventSpecCache.d.ts

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