avo-inspector 3.2.0 → 3.2.3

package/dist/__tests__/BatcherPublic.js

@@ -1,139 +0,0 @@
-"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 });
-var AvoBatcher_1 = require("../AvoBatcher");
-var AvoInspector_1 = require("../AvoInspector");
-var AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
-var AvoStreamId_1 = require("../AvoStreamId");
-var constants_1 = require("./constants");
-var inspectorVersion = process.env.npm_package_version || "";
-jest.mock("../AvoBatcher");
-jest.mock("../AvoStorage");
-jest.spyOn(AvoStreamId_1.AvoStreamId, "initialize").mockResolvedValue(constants_1.mockedReturns.ANONYMOUS_ID);
-describe("Batcher", function () {
-    var inspector;
-    var apiKey = constants_1.defaultOptions.apiKey, env = constants_1.defaultOptions.env, version = constants_1.defaultOptions.version;
-    var networkHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(apiKey, env, "", version, inspectorVersion);
-    beforeAll(function () {
-        inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-    });
-    afterEach(function () {
-        jest.clearAllMocks();
-        // @ts-ignore
-        inspector.avoDeduplicator._clearEvents();
-    });
-    test("Batcher is initialized on Inspector init", function () {
-        expect(AvoBatcher_1.AvoBatcher).toHaveBeenCalledTimes(1);
-        expect(AvoBatcher_1.AvoBatcher).toHaveBeenCalledWith(networkHandler);
-    });
-    test("handleTrackSchema is called on trackSchema", function () {
-        var eventName = "event name";
-        var schema = [
-            {
-                propertyName: "prop0",
-                propertyType: "string",
-            },
-            {
-                propertyName: "prop1",
-                propertyType: "string",
-            },
-        ];
-        inspector.trackSchema(eventName, schema);
-        expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-        expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(eventName, schema, null, null, undefined);
-    });
-    test("handleTrackSchema is called on trackSchemaFromEvent", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var eventName, properties, schema;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    eventName = "event name";
-                    properties = {
-                        prop0: "",
-                        prop2: false,
-                        prop3: 0,
-                        prop4: 0.0,
-                    };
-                    schema = inspector.extractSchema(properties);
-                    return [4 /*yield*/, inspector.trackSchemaFromEvent(eventName, properties)];
-                case 1:
-                    _a.sent();
-                    expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-                    expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(eventName, schema, null, null, properties);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var eventName, properties, eventId, eventHash, schema;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    eventName = "event name";
-                    properties = {
-                        prop0: "",
-                        prop2: false,
-                        prop3: 0,
-                        prop4: 0.0,
-                    };
-                    eventId = "testId";
-                    eventHash = "testHash";
-                    schema = inspector.extractSchema(properties);
-                    // @ts-ignore
-                    return [4 /*yield*/, inspector._avoFunctionTrackSchemaFromEvent(eventName, properties, eventId, eventHash)];
-                case 1:
-                    // @ts-ignore
-                    _a.sent();
-                    expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-                    expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(eventName, schema, eventId, eventHash, properties);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    test("batchSize is updated", function () {
-        var count = 10;
-        inspector.setBatchSize(count);
-        expect(AvoInspector_1.AvoInspector.batchSize).toBe(count);
-    });
-    test("batchFlushSeconds is updated", function () {
-        var seconds = 10;
-        inspector.setBatchFlushSeconds(seconds);
-        expect(AvoInspector_1.AvoInspector.batchFlushSeconds).toBe(seconds);
-    });
-});

package/dist/__tests__/Deduplicator.js

@@ -1,190 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 });
-var AvoDeduplicator_1 = require("../AvoDeduplicator");
-var utils_1 = require("../utils");
-var AvoSchemaParser_1 = require("../AvoSchemaParser");
-var AvoInspector_1 = require("../AvoInspector");
-var constants_1 = require("./constants");
-describe("Deduplicator", function () {
-    var deduplicator = new AvoDeduplicator_1.AvoDeduplicator();
-    var testObject = {
-        "0": "some string",
-        "1": [1, 2, 3],
-        2: [["str", true]],
-        3: { avo: [1.1, 2.2, 3.3] }
-    };
-    test("AvoDeduplicator.deepEqual tests", function () {
-        var secondObject = {
-            "0": "some string",
-            "1": [1, 2, 3],
-            2: [["str", true]],
-            3: { avo: [1.1, 2.2, 3.3] }
-        };
-        expect((0, utils_1.deepEquals)(testObject, secondObject)).toBe(true);
-        expect((0, utils_1.deepEquals)(testObject, __assign(__assign({}, secondObject), { "4": "4" }))).toBe(false);
-        expect((0, utils_1.deepEquals)(testObject, __assign(__assign({}, secondObject), { 3: __assign(__assign({}, secondObject[3]), { avo: [1.1] }) }))).toBe(false);
-        expect((0, utils_1.deepEquals)(testObject, __assign(__assign({}, secondObject), { 0: "other string" }))).toBe(false);
-    });
-    test("Detects duplications when track in avo and then manually", function () {
-        var shouldRegisterFromAvo = deduplicator.shouldRegisterEvent("Test", testObject, true);
-        var shouldRegisterManual = deduplicator.shouldRegisterEvent("Test", testObject, false);
-        expect(shouldRegisterFromAvo).toBe(true);
-        expect(shouldRegisterManual).toBe(false);
-    });
-    test("Detects duplications when track manually and then in avo", function () {
-        var shouldRegisterManual = deduplicator.shouldRegisterEvent("Test", testObject, false);
-        var shouldRegisterFromAvo = deduplicator.shouldRegisterEvent("Test", testObject, true);
-        expect(shouldRegisterManual).toBe(true);
-        expect(shouldRegisterFromAvo).toBe(false);
-    });
-    test("Detects duplications when track in avo and then schema manually", function () {
-        var shouldRegisterFromAvo = deduplicator.shouldRegisterEvent("Test", testObject, true);
-        var shouldRegisterSchemaManual = deduplicator.shouldRegisterSchemaFromManually("Test", AvoSchemaParser_1.AvoSchemaParser.extractSchema(testObject));
-        expect(shouldRegisterFromAvo).toBe(true);
-        expect(shouldRegisterSchemaManual).toBe(false);
-    });
-    test("Inspector deduplicates only one event when track manually, in avo and then manually again", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var inspector, manuallyTrackedSchema, avoTrackedSchema, manuallyTrackedSchemaAgain;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-                    inspector.enableLogging(false);
-                    return [4 /*yield*/, inspector.trackSchemaFromEvent("test", testObject)];
-                case 1:
-                    manuallyTrackedSchema = _a.sent();
-                    return [4 /*yield*/, inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash")];
-                case 2:
-                    avoTrackedSchema = _a.sent();
-                    return [4 /*yield*/, inspector.trackSchemaFromEvent("test", testObject)];
-                case 3:
-                    manuallyTrackedSchemaAgain = _a.sent();
-                    expect(manuallyTrackedSchema.length).toBe(4);
-                    expect(avoTrackedSchema.length).toBe(0);
-                    expect(manuallyTrackedSchemaAgain.length).toBe(4);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    test("Inspector deduplicates only one event when track in avo, manually and then in avo again", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var inspector, avoTrackedSchema, manuallyTrackedSchema, avoTrackedSchemaAgain;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-                    inspector.enableLogging(false);
-                    return [4 /*yield*/, inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash")];
-                case 1:
-                    avoTrackedSchema = _a.sent();
-                    return [4 /*yield*/, inspector.trackSchemaFromEvent("test", testObject)];
-                case 2:
-                    manuallyTrackedSchema = _a.sent();
-                    return [4 /*yield*/, inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash")];
-                case 3:
-                    avoTrackedSchemaAgain = _a.sent();
-                    expect(avoTrackedSchema.length).toBe(4);
-                    expect(manuallyTrackedSchema.length).toBe(0);
-                    expect(avoTrackedSchemaAgain.length).toBe(4);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    test("Allows two same manual events in a row", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var inspector, manuallyTrackedSchema, manuallyTrackedSchemaAgain;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-                    inspector.enableLogging(false);
-                    return [4 /*yield*/, inspector.trackSchemaFromEvent("test", testObject)];
-                case 1:
-                    manuallyTrackedSchema = _a.sent();
-                    return [4 /*yield*/, inspector.trackSchemaFromEvent("test", testObject)];
-                case 2:
-                    manuallyTrackedSchemaAgain = _a.sent();
-                    expect(manuallyTrackedSchema.length).toBe(4);
-                    expect(manuallyTrackedSchemaAgain.length).toBe(4);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    test("Allows two same avo events in a row", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var inspector, avoTrackedSchema, avoTrackedSchemaAgain;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-                    inspector.enableLogging(false);
-                    return [4 /*yield*/, inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash")];
-                case 1:
-                    avoTrackedSchema = _a.sent();
-                    return [4 /*yield*/, inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash")];
-                case 2:
-                    avoTrackedSchemaAgain = _a.sent();
-                    expect(avoTrackedSchema.length).toBe(4);
-                    expect(avoTrackedSchemaAgain.length).toBe(4);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    test("Does not deduplicate if more than 300ms pass", function () {
-        var shouldRegisterFromAvo = deduplicator.shouldRegisterEvent("Test", testObject, true);
-        var now = new Date();
-        var dateNowSpy = jest
-            .spyOn(Date, "now")
-            .mockImplementation(function () {
-            return now.setMilliseconds(now.getMilliseconds() + 301);
-        });
-        var shouldRegisterManual = deduplicator.shouldRegisterEvent("Test", testObject, false);
-        expect(shouldRegisterFromAvo).toBe(true);
-        expect(shouldRegisterManual).toBe(true);
-        dateNowSpy.mockRestore();
-    });
-});

package/dist/__tests__/EventSpecCache.js

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var AvoEventSpecCache_1 = require("../eventSpec/AvoEventSpecCache");
-function makeSpec(branchId) {
-    if (branchId === void 0) { branchId = "branch1"; }
-    return {
-        events: [
-            {
-                branchId: branchId,
-                baseEventId: "evt_1",
-                variantIds: [],
-                props: {
-                    method: { type: "string", required: true },
-                },
-            },
-        ],
-        metadata: {
-            schemaId: "schema1",
-            branchId: branchId,
-            latestActionId: "action1",
-        },
-    };
-}
-describe("EventSpecCache", function () {
-    var cache;
-    beforeEach(function () {
-        cache = new AvoEventSpecCache_1.EventSpecCache(false);
-    });
-    test("returns undefined on cache miss", function () {
-        var result = cache.get("key", "stream", "event");
-        expect(result).toBeUndefined();
-    });
-    test("stores and retrieves a spec", function () {
-        var spec = makeSpec();
-        cache.set("key", "stream", "event", spec);
-        var result = cache.get("key", "stream", "event");
-        expect(result).toEqual(spec);
-    });
-    test("caches null spec responses", function () {
-        cache.set("key", "stream", "event", null);
-        var result = cache.get("key", "stream", "event");
-        expect(result).toBeNull();
-    });
-    test("TTL eviction: entries older than 60s removed on next get", function () {
-        var spec = makeSpec();
-        cache.set("key", "stream", "event", spec);
-        // Fast-forward time by 61 seconds
-        var now = Date.now();
-        jest.spyOn(Date, "now").mockReturnValue(now + 61000);
-        var result = cache.get("key", "stream", "event");
-        expect(result).toBeUndefined();
-        expect(cache.size()).toBe(0);
-        jest.restoreAllMocks();
-    });
-    test("per-entry eviction: entries retrieved 50+ times evicted immediately on next get", function () {
-        var spec = makeSpec();
-        cache.set("key", "stream", "event", spec);
-        // Access 50 times (reaching the threshold)
-        for (var i = 0; i < 50; i++) {
-            cache.get("key", "stream", "event");
-        }
-        // 51st access should evict
-        var result = cache.get("key", "stream", "event");
-        expect(result).toBeUndefined();
-    });
-    test("global sweep: runs every 50 cache operations and removes expired entries", function () {
-        var now = Date.now();
-        var dateSpy = jest.spyOn(Date, "now");
-        // Add an entry that will be old
-        dateSpy.mockReturnValue(now);
-        cache.set("key", "stream", "old-event", makeSpec());
-        // Add entries that will be fresh
-        dateSpy.mockReturnValue(now + 59000);
-        cache.set("key", "stream", "fresh-event", makeSpec());
-        // Access fresh-event 50 times to trigger sweep (at now + 59000, old-event has age 59000 which is < 60000)
-        // But let's make old-event actually expired
-        dateSpy.mockReturnValue(now + 61000);
-        // We need 50 operations to trigger sweep. Access fresh-event repeatedly.
-        // fresh-event was set at now+59000, so at now+61000 it's only 2s old
-        for (var i = 0; i < 49; i++) {
-            cache.get("key", "stream", "fresh-event");
-        }
-        // The 50th get triggers sweep
-        cache.get("key", "stream", "fresh-event");
-        // old-event should be swept (age > 60s)
-        // But fresh-event hit 50 times so per-entry eviction kicks in on next get
-        expect(cache.size()).toBeLessThanOrEqual(1);
-        jest.restoreAllMocks();
-    });
-    test("cache capacity: LRU eviction when size > 50", function () {
-        // Fill cache to capacity
-        for (var i = 0; i < 50; i++) {
-            cache.set("key", "stream", "event-".concat(i), makeSpec());
-        }
-        expect(cache.size()).toBe(50);
-        // Adding one more should evict the LRU entry
-        cache.set("key", "stream", "event-new", makeSpec());
-        expect(cache.size()).toBe(50);
-    });
-    test("LRU eviction removes least recently used entry", function () {
-        var now = Date.now();
-        var dateSpy = jest.spyOn(Date, "now");
-        // Add entries with different timestamps
-        dateSpy.mockReturnValue(now);
-        cache.set("key", "stream", "event-0", makeSpec());
-        dateSpy.mockReturnValue(now + 1000);
-        cache.set("key", "stream", "event-1", makeSpec());
-        // Access event-0 to update its lastAccessed
-        dateSpy.mockReturnValue(now + 2000);
-        cache.get("key", "stream", "event-0");
-        // Fill to capacity
-        for (var i = 2; i < 50; i++) {
-            dateSpy.mockReturnValue(now + 3000 + i);
-            cache.set("key", "stream", "event-".concat(i), makeSpec());
-        }
-        // Add one more - should evict event-1 (least recently accessed at now+1000)
-        dateSpy.mockReturnValue(now + 4000);
-        cache.set("key", "stream", "event-new", makeSpec());
-        // event-1 should be evicted
-        var evicted = cache.get("key", "stream", "event-1");
-        expect(evicted).toBeUndefined();
-        // event-0 should still be present
-        var kept = cache.get("key", "stream", "event-0");
-        expect(kept).toBeDefined();
-        jest.restoreAllMocks();
-    });
-    test("clear removes all entries and resets counter", function () {
-        cache.set("key", "stream", "event1", makeSpec());
-        cache.set("key", "stream", "event2", makeSpec());
-        expect(cache.size()).toBe(2);
-        cache.clear();
-        expect(cache.size()).toBe(0);
-        expect(cache.get("key", "stream", "event1")).toBeUndefined();
-    });
-    test("getStats returns correct statistics", function () {
-        cache.set("key", "stream", "event1", makeSpec());
-        cache.get("key", "stream", "event1");
-        var stats = cache.getStats();
-        expect(stats.size).toBe(1);
-        expect(stats.entries.length).toBe(1);
-        expect(stats.entries[0].eventCount).toBe(1);
-    });
-});