avo-inspector 3.1.0-alpha.2 → 3.2.0

package/dist/AvoNetworkCallsHandler.d.ts

@@ -79,6 +79,12 @@ export declare class AvoNetworkCallsHandler {
     private shouldDropBySampling;
     /**
      * Core Inspector API call logic shared by batch and immediate calls.
+     *
+     * Bodies large enough to be worth it are gzipped (with Content-Encoding: gzip)
+     * to cut network volume ~10x. When CompressionStream is unavailable or
+     * compression fails, the body is sent uncompressed exactly as before —
+     * synchronously in the unavailable case, so legacy timing is preserved.
      */
     private callInspectorApi;
+    private sendTrackingRequest;
 }

package/dist/AvoNetworkCallsHandler.js

@@ -1,11 +1,48 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoNetworkCallsHandler = void 0;
-const AvoGuid_1 = require("./AvoGuid");
-const AvoInspector_1 = require("./AvoInspector");
-const AvoStreamId_1 = require("./AvoStreamId");
-class AvoNetworkCallsHandler {
-    constructor(apiKey, envName, appName, appVersion, libVersion, publicEncryptionKey) {
+var AvoGuid_1 = require("./AvoGuid");
+var AvoInspector_1 = require("./AvoInspector");
+var AvoStreamId_1 = require("./AvoStreamId");
+var AvoEncryption_1 = require("./AvoEncryption");
+var AvoNetworkCallsHandler = /** @class */ (function () {
+    function AvoNetworkCallsHandler(apiKey, envName, appName, appVersion, libVersion, publicEncryptionKey) {
         this.samplingRate = 1.0;
         this.sending = false;
         this.apiKey = apiKey;
@@ -15,17 +52,17 @@ class AvoNetworkCallsHandler {
         this.libVersion = libVersion;
         this.publicEncryptionKey = publicEncryptionKey;
     }
-    callInspectorWithBatchBody(inEvents, onCompleted) {
+    AvoNetworkCallsHandler.prototype.callInspectorWithBatchBody = function (inEvents, onCompleted) {
+        var _this = this;
         if (this.sending) {
-            onCompleted(new Error("Batch sending cancelled because another batch sending is in progress. Your events will be sent with next batch."));
+            onCompleted("Batch sending cancelled because another batch sending is in progress. Your events will be sent with next batch.");
             return;
         }
-        const events = inEvents.filter((x) => x != null);
-        this.fixStreamIds(events);
+        var events = inEvents.filter(function (x) { return x != null; });
         if (events.length === 0) {
             return;
         }
-        if (this.shouldDropBySampling()) {
+        if (Math.random() > this.samplingRate) {
             if (AvoInspector_1.AvoInspector.shouldLog) {
                 console.log("Avo Inspector: last event schema dropped due to sampling rate.");
             }
@@ -33,153 +70,160 @@ class AvoNetworkCallsHandler {
         }
         if (AvoInspector_1.AvoInspector.shouldLog) {
             console.log("Avo Inspector: events", events);
-            events.forEach((event) => {
-                if (event.type === "sessionStarted") {
-                    console.log("Avo Inspector: sending session started event.");
-                }
-                else if (event.type === "event") {
-                    console.log("Avo Inspector: sending event " +
-                        event.eventName +
-                        " with schema " +
-                        JSON.stringify(event.eventProperties));
+            events.forEach(function (event) {
+                if (event.type === "event") {
+                    var schemaEvent = event;
+                    console.log("Avo Inspector: sending event " + schemaEvent.eventName + " with schema " + JSON.stringify(schemaEvent.eventProperties));
                 }
             });
         }
         this.sending = true;
-        this.callInspectorApi(events, (error) => {
-            this.sending = false;
-            onCompleted(error);
-        });
-    }
-    fixStreamIds(events) {
-        let knownStreamId = null;
-        events.forEach(function (event) {
-            if (event.streamId !== null &&
-                event.streamId !== undefined &&
-                event.streamId !== "unknown") {
-                knownStreamId = event.streamId;
+        var xmlhttp = new XMLHttpRequest();
+        xmlhttp.open("POST", AvoNetworkCallsHandler.trackingEndpoint, true);
+        xmlhttp.setRequestHeader("Content-Type", "application/json");
+        xmlhttp.setRequestHeader("Accept", "application/json");
+        xmlhttp.timeout = 10000;
+        xmlhttp.onload = function () {
+            _this.sending = false;
+            if (xmlhttp.status != 200) {
+                onCompleted("Error ".concat(xmlhttp.status, ": ").concat(xmlhttp.statusText));
             }
-        });
-        events.forEach(function (event) {
-            if (event.streamId === "unknown") {
-                if (knownStreamId != null) {
-                    event.streamId = knownStreamId;
+            else {
+                try {
+                    var samplingRate = JSON.parse(xmlhttp.response).samplingRate;
+                    if (samplingRate !== undefined) {
+                        _this.samplingRate = samplingRate;
+                    }
                 }
-                else {
-                    event.streamId = AvoStreamId_1.AvoStreamId.streamId;
+                catch (_) {
+                    // Ignore malformed response — sampling rate stays unchanged
                 }
+                onCompleted(null);
             }
+        };
+        xmlhttp.onerror = function () {
+            _this.sending = false;
+            onCompleted("Request failed");
+        };
+        xmlhttp.ontimeout = function () {
+            _this.sending = false;
+            onCompleted("Request timed out");
+        };
+        xmlhttp.send(JSON.stringify(events));
+    };
+    AvoNetworkCallsHandler.prototype.bodyForEventSchemaCall = function (eventName, eventProperties, eventId, eventHash, eventProps, metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var anonymousId, eventSchemaBody;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, AvoStreamId_1.AvoStreamId.initialize()];
+                    case 1:
+                        anonymousId = _a.sent();
+                        eventSchemaBody = this.createBaseCallBody(anonymousId);
+                        eventSchemaBody.type = "event";
+                        eventSchemaBody.eventName = eventName;
+                        // Encrypt property values when encryption is enabled
+                        if ((0, AvoEncryption_1.shouldEncrypt)(this.envName, this.publicEncryptionKey) &&
+                            eventProps) {
+                            eventSchemaBody.eventProperties = (0, AvoEncryption_1.encryptEventProperties)(eventProperties, eventProps, this.publicEncryptionKey);
+                        }
+                        else {
+                            eventSchemaBody.eventProperties = eventProperties;
+                        }
+                        if (eventId != null) {
+                            eventSchemaBody.avoFunction = true;
+                            eventSchemaBody.eventId = eventId;
+                            eventSchemaBody.eventHash = eventHash;
+                        }
+                        else {
+                            eventSchemaBody.avoFunction = false;
+                            eventSchemaBody.eventId = null;
+                            eventSchemaBody.eventHash = null;
+                        }
+                        // Add streamId and event spec metadata for validated events
+                        if (metadata) {
+                            eventSchemaBody.streamId = anonymousId;
+                            eventSchemaBody.eventSpecMetadata = {};
+                            if (metadata.schemaId) {
+                                eventSchemaBody.eventSpecMetadata.schemaId = metadata.schemaId;
+                            }
+                            if (metadata.branchId) {
+                                eventSchemaBody.eventSpecMetadata.branchId = metadata.branchId;
+                            }
+                            if (metadata.latestActionId) {
+                                eventSchemaBody.eventSpecMetadata.latestActionId = metadata.latestActionId;
+                            }
+                            if (metadata.sourceId) {
+                                eventSchemaBody.eventSpecMetadata.sourceId = metadata.sourceId;
+                            }
+                        }
+                        return [2 /*return*/, eventSchemaBody];
+                }
+            });
         });
-    }
-    bodyForSessionStartedCall() {
-        const sessionBody = this.createBaseCallBody();
-        sessionBody.type = "sessionStarted";
-        return sessionBody;
-    }
-    bodyForEventSchemaCall(eventName, eventProperties, eventId, eventHash, eventSpecMetadata, validatedBranchId) {
-        const eventSchemaBody = this.createBaseCallBody();
-        eventSchemaBody.type = "event";
-        eventSchemaBody.eventName = eventName;
-        eventSchemaBody.eventProperties = eventProperties;
-        if (eventId != null) {
-            eventSchemaBody.avoFunction = true;
-            eventSchemaBody.eventId = eventId;
-            eventSchemaBody.eventHash = eventHash;
-        }
-        else {
-            eventSchemaBody.avoFunction = false;
-            eventSchemaBody.eventId = null;
-            eventSchemaBody.eventHash = null;
-        }
-        // Set metadata on base body if provided
-        if (eventSpecMetadata) {
-            eventSchemaBody.eventSpecMetadata = eventSpecMetadata;
+    };
+    /**
+     * Sends a validated event immediately, bypassing the batcher.
+     * Matches Android SDK's reportValidatedEvent behavior.
+     */
+    AvoNetworkCallsHandler.prototype.reportValidatedEvent = function (eventBody) {
+        if (Math.random() > this.samplingRate) {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.log("Avo Inspector: validated event dropped due to sampling rate.");
+            }
+            return;
         }
-        // Set validated branch ID if value validation was performed
-        if (validatedBranchId) {
-            eventSchemaBody.validatedBranchId = validatedBranchId;
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.log("Avo Inspector: sending validated event " +
+                eventBody.eventName +
+                " with schema " +
+                JSON.stringify(eventBody.eventProperties));
         }
-        return eventSchemaBody;
-    }
-    createBaseCallBody() {
-        const body = {
+        var xmlhttp = new XMLHttpRequest();
+        xmlhttp.open("POST", AvoNetworkCallsHandler.trackingEndpoint, true);
+        xmlhttp.setRequestHeader("Content-Type", "application/json");
+        xmlhttp.setRequestHeader("Accept", "application/json");
+        xmlhttp.timeout = 10000;
+        xmlhttp.onload = function () {
+            if (xmlhttp.status !== 200 && AvoInspector_1.AvoInspector.shouldLog) {
+                console.warn("Avo Inspector: validated event response status ".concat(xmlhttp.status));
+            }
+        };
+        xmlhttp.onerror = function () {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.warn("Avo Inspector: failed to send validated event");
+            }
+        };
+        xmlhttp.ontimeout = function () {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.warn("Avo Inspector: validated event report timed out");
+            }
+        };
+        xmlhttp.send(JSON.stringify([eventBody]));
+    };
+    AvoNetworkCallsHandler.prototype.createBaseCallBody = function (anonymousId) {
+        var body = {
             apiKey: this.apiKey,
             appName: this.appName,
             appVersion: this.appVersion,
             libVersion: this.libVersion,
             env: this.envName,
-            libPlatform: "web",
+            libPlatform: "react-native",
             messageId: AvoGuid_1.default.newGuid(),
             trackingId: "",
-            createdAt: new Date().toISOString(),
             sessionId: "",
-            streamId: AvoStreamId_1.AvoStreamId.streamId,
-            samplingRate: this.samplingRate
+            anonymousId: anonymousId,
+            createdAt: new Date().toISOString(),
+            samplingRate: this.samplingRate,
         };
-        if (this.publicEncryptionKey) {
+        if (this.publicEncryptionKey !== null &&
+            this.publicEncryptionKey !== undefined &&
+            this.publicEncryptionKey.trim().length > 0) {
             body.publicEncryptionKey = this.publicEncryptionKey;
         }
         return body;
-    }
-    /**
-     * Calls Inspector API immediately with a single event (bypasses batching).
-     * Used when event spec validation is available.
-     * Note: Does not drop due to sampling - validated events are always sent.
-     */
-    callInspectorImmediately(eventBody, onCompleted) {
-        // Fix stream ID if needed
-        if (eventBody.streamId === "unknown") {
-            eventBody.streamId = AvoStreamId_1.AvoStreamId.streamId;
-        }
-        if (AvoInspector_1.AvoInspector.shouldLog) {
-            console.log("Avo Inspector: calling inspector immediately (with validation)", eventBody.eventName);
-            console.log("Avo Inspector: event body", eventBody);
-        }
-        this.callInspectorApi([eventBody], onCompleted);
-    }
-    /**
-     * Check if event should be dropped based on sampling rate.
-     */
-    shouldDropBySampling() {
-        return Math.random() > this.samplingRate;
-    }
-    /**
-     * Core Inspector API call logic shared by batch and immediate calls.
-     */
-    callInspectorApi(events, onCompleted) {
-        const xmlhttp = new XMLHttpRequest();
-        xmlhttp.open("POST", AvoNetworkCallsHandler.trackingEndpoint, true);
-        xmlhttp.setRequestHeader("Content-Type", "text/plain");
-        xmlhttp.timeout = AvoInspector_1.AvoInspector.networkTimeout;
-        xmlhttp.send(JSON.stringify(events));
-        xmlhttp.onload = () => {
-            if (xmlhttp.status !== 200) {
-                onCompleted(new Error(`Error ${xmlhttp.status}: ${xmlhttp.statusText}`));
-            }
-            else {
-                let response;
-                try {
-                    response = JSON.parse(xmlhttp.response);
-                }
-                catch (e) {
-                    onCompleted(new Error(`Failed to parse response: ${e instanceof Error ? e.message : String(e)}`));
-                    return;
-                }
-                if (response != null &&
-                    typeof response.samplingRate === "number" &&
-                    !isNaN(response.samplingRate)) {
-                    this.samplingRate = response.samplingRate;
-                }
-                onCompleted(null);
-            }
-        };
-        xmlhttp.onerror = () => {
-            onCompleted(new Error("Request failed"));
-        };
-        xmlhttp.ontimeout = () => {
-            onCompleted(new Error("Request timed out"));
-        };
-    }
-}
+    };
+    AvoNetworkCallsHandler.trackingEndpoint = "https://api.avo.app/inspector/v1/track";
+    return AvoNetworkCallsHandler;
+}());
 exports.AvoNetworkCallsHandler = AvoNetworkCallsHandler;
-AvoNetworkCallsHandler.trackingEndpoint = "https://api.avo.app/inspector/v1/track";

package/dist/AvoSchemaParser.js

@@ -1,73 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoSchemaParser = void 0;
-const isArray = (obj) => {
+var isArray = function (obj) {
     return Object.prototype.toString.call(obj) === "[object Array]";
 };
-let _encryptValueFn;
-class AvoSchemaParser {
-    /**
-     * Returns true only if we have a valid encryption key and can send encrypted values.
-     * If no key is present, returns false and no property values will be sent.
-     */
-    static canSendEncryptedValues(publicEncryptionKey, env) {
-        const hasEncryptionKey = publicEncryptionKey != null && publicEncryptionKey !== "";
-        const isDevOrStaging = env === "dev" || env === "staging";
-        return hasEncryptionKey && isDevOrStaging;
+var AvoSchemaParser = /** @class */ (function () {
+    function AvoSchemaParser() {
     }
-    /**
-     * Returns the encrypted property value if encryption is enabled, otherwise undefined.
-     * Never returns unencrypted values - only encrypted or nothing.
-     */
-    static async getEncryptedPropertyValueIfEnabled(propertyValue, canEncrypt, publicEncryptionKey) {
-        if (!canEncrypt || !publicEncryptionKey) {
-            return undefined; // No encryption key: do not send any property values
-        }
-        try {
-            if (!_encryptValueFn) {
-                const { encryptValue } = await Promise.resolve().then(() => require("./AvoEncryption"));
-                _encryptValueFn = encryptValue;
-            }
-            return await _encryptValueFn(propertyValue, publicEncryptionKey); // Only send encrypted values
-        }
-        catch (error) {
-            // If encryption fails, log the error but don't fail the entire schema extraction
-            console.error("[Avo Inspector] Failed to encrypt property value:", error instanceof Error ? error.message : String(error));
-            return undefined;
-        }
-    }
-    static async extractSchema(eventProperties, publicEncryptionKey, env) {
+    AvoSchemaParser.extractSchema = function (eventProperties) {
+        var _this = this;
         if (eventProperties === null || eventProperties === undefined) {
             return [];
         }
-        const canSendEncryptedValues = this.canSendEncryptedValues(publicEncryptionKey, env);
-        const mapping = async (object) => {
+        var mapping = function (object) {
             if (isArray(object)) {
-                const list = await Promise.all(object.map(async (x) => {
-                    return await mapping(x);
-                }));
-                return this.removeDuplicates(list);
+                var list = object.map(function (x) {
+                    return mapping(x);
+                });
+                return _this.removeDuplicates(list);
             }
             else if (typeof object === "object") {
-                const mappedResult = [];
-                for (const key in object) {
+                var mappedResult = [];
+                for (var key in object) {
                     if (object.hasOwnProperty(key)) {
-                        const val = object[key];
-                        const mappedEntry = {
+                        var val = object[key];
+                        var mappedEntry = {
                             propertyName: key,
-                            propertyType: this.getPropValueType(val)
+                            propertyType: _this.getPropValueType(val),
                         };
                         if (typeof val === "object" && val != null) {
-                            // Object/array properties: children are encrypted individually, no need to encrypt parent
-                            mappedEntry.children = (await mapping(val));
-                        }
-                        else if (val !== undefined) {
-                            // Primitive properties: encrypt the value if encryption is enabled
-                            // Skip undefined values - they can't be encrypted and shouldn't be sent
-                            const encryptedValue = await this.getEncryptedPropertyValueIfEnabled(val, canSendEncryptedValues, publicEncryptionKey);
-                            if (encryptedValue !== undefined) {
-                                mappedEntry.encryptedPropertyValue = encryptedValue;
-                            }
+                            mappedEntry["children"] = mapping(val);
                         }
                         mappedResult.push(mappedEntry);
                     }
@@ -75,30 +37,30 @@ class AvoSchemaParser {
                 return mappedResult;
             }
             else {
-                return this.getPropValueType(object);
+                return _this.getPropValueType(object);
             }
         };
-        // eventProperties is always an object (Record), so mapping returns EventProperty[]
-        const mappedEventProps = (await mapping(eventProperties));
+        var mappedEventProps = mapping(eventProperties);
         return mappedEventProps;
-    }
-    static removeDuplicates(array) {
-        const primitives = { boolean: {}, number: {}, string: {} };
-        const objects = [];
-        return array.filter((item) => {
-            const type = typeof item;
-            if (type in primitives && typeof item === "string") {
+    };
+    AvoSchemaParser.removeDuplicates = function (array) {
+        // XXX TODO fix any types
+        var primitives = { boolean: {}, number: {}, string: {} };
+        var objects = [];
+        return array.filter(function (item) {
+            var type = typeof item;
+            if (type in primitives) {
                 return primitives[type].hasOwnProperty(item)
                     ? false
                     : (primitives[type][item] = true);
             }
             else {
-                return objects.includes(item) ? false : objects.push(item);
+                return objects.indexOf(item) >= 0 ? false : objects.push(item);
             }
         });
-    }
-    static getPropValueType(propValue) {
-        const propType = typeof propValue;
+    };
+    AvoSchemaParser.getPropValueType = function (propValue) {
+        var propType = typeof propValue;
         if (propValue == null) {
             return "null";
         }
@@ -106,7 +68,7 @@ class AvoSchemaParser {
             return "string";
         }
         else if (propType === "number" || propType === "bigint") {
-            if ((propValue + "").includes(".")) {
+            if ((propValue + "").indexOf(".") >= 0) {
                 return "float";
             }
             else {
@@ -127,6 +89,7 @@ class AvoSchemaParser {
         else {
             return "unknown";
         }
-    }
-}
+    };
+    return AvoSchemaParser;
+}());
 exports.AvoSchemaParser = AvoSchemaParser;