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

package/dist/__tests__/TestEventValidator.js

@@ -1,196 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const EventValidator_1 = require("../eventSpec/EventValidator");
-// We need to mock safe-regex2 for some tests
-jest.mock("safe-regex2", () => {
-    const actual = jest.requireActual("safe-regex2");
-    return {
-        __esModule: true,
-        default: actual.default || actual,
-        _mockable: true,
-    };
-});
-describe("EventValidator", () => {
-    let validator;
-    beforeEach(() => {
-        validator = new EventValidator_1.EventValidator();
-        jest.spyOn(console, "warn").mockImplementation(() => { });
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe("type validation", () => {
-        test("passes when property types match spec", () => {
-            const spec = {
-                eventName: "click",
-                properties: [
-                    { propertyName: "target", propertyType: "string" },
-                    { propertyName: "count", propertyType: "int" },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "target", propertyType: "string" },
-                { propertyName: "count", propertyType: "int" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-1");
-            // All properties passed type check, so failedEventIds should be empty
-            expect(results.every((r) => r.failedEventIds.length === 0)).toBe(true);
-            // Bandwidth optimization: passedEventIds cleared because passed >= failed for each property
-            expect(results.every((r) => r.passedEventIds.length === 0)).toBe(true);
-        });
-        test("fails when property type does not match spec", () => {
-            const spec = {
-                eventName: "click",
-                properties: [{ propertyName: "count", propertyType: "int" }],
-            };
-            const eventProperties = [
-                { propertyName: "count", propertyType: "string" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-2");
-            const countResult = results.find((r) => r.propertyName === "count");
-            expect(countResult === null || countResult === void 0 ? void 0 : countResult.failedEventIds).toContain("evt-2");
-            expect(countResult === null || countResult === void 0 ? void 0 : countResult.passedEventIds).not.toContain("evt-2");
-        });
-        test("fails for missing required properties", () => {
-            const spec = {
-                eventName: "click",
-                properties: [
-                    { propertyName: "target", propertyType: "string" },
-                    { propertyName: "count", propertyType: "int" },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "target", propertyType: "string" },
-                // count is missing
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-3");
-            const countResult = results.find((r) => r.propertyName === "count");
-            expect(countResult === null || countResult === void 0 ? void 0 : countResult.failedEventIds).toContain("evt-3");
-        });
-    });
-    describe("regex validation", () => {
-        test("passes when value matches safe regex pattern (type match)", () => {
-            const spec = {
-                eventName: "navigate",
-                properties: [
-                    {
-                        propertyName: "url",
-                        propertyType: "string",
-                        regex: "^https://",
-                    },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "url", propertyType: "string", propertyValue: "https://example.com" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-4");
-            const urlResult = results.find((r) => r.propertyName === "url");
-            // Type matches and regex matches, property passed. Bandwidth optimization: passedEventIds cleared
-            // because passed count (1) >= failed count (0)
-            expect(urlResult === null || urlResult === void 0 ? void 0 : urlResult.failedEventIds).toEqual([]);
-        });
-        test("fails when value does not match safe regex pattern", () => {
-            const spec = {
-                eventName: "navigate",
-                properties: [
-                    {
-                        propertyName: "url",
-                        propertyType: "string",
-                        regex: "^https://",
-                    },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "url", propertyType: "string", propertyValue: "http://example.com" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-regex-fail");
-            const urlResult = results.find((r) => r.propertyName === "url");
-            expect(urlResult === null || urlResult === void 0 ? void 0 : urlResult.failedEventIds).toContain("evt-regex-fail");
-            expect(urlResult === null || urlResult === void 0 ? void 0 : urlResult.passedEventIds).not.toContain("evt-regex-fail");
-        });
-        test("logs warning and passes type check when regex syntax is invalid", () => {
-            const spec = {
-                eventName: "filter",
-                properties: [
-                    {
-                        propertyName: "pattern",
-                        propertyType: "string",
-                        regex: "[invalid",
-                    },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "pattern", propertyType: "string", propertyValue: "anything" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-bad-regex");
-            const patternResult = results.find((r) => r.propertyName === "pattern");
-            // Invalid regex is caught, property still passes type check
-            expect(patternResult === null || patternResult === void 0 ? void 0 : patternResult.failedEventIds).toEqual([]);
-            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("[Avo Inspector] Warning"));
-        });
-        test("skips unsafe regex patterns with warning", () => {
-            const spec = {
-                eventName: "search",
-                properties: [
-                    {
-                        propertyName: "query",
-                        propertyType: "string",
-                        // Catastrophic backtracking pattern
-                        regex: "(a+)+$",
-                    },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "query", propertyType: "string", propertyValue: "aaa" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-5");
-            // Unsafe regex should be skipped, property still passes type check
-            const queryResult = results.find((r) => r.propertyName === "query");
-            // Bandwidth optimization: passedEventIds cleared because passed count >= failed count
-            expect(queryResult === null || queryResult === void 0 ? void 0 : queryResult.failedEventIds).toEqual([]);
-            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("[Avo Inspector] Warning"));
-        });
-    });
-    describe("extra/unexpected properties", () => {
-        test("ignores properties present in event but not in the spec", () => {
-            const spec = {
-                eventName: "click",
-                properties: [
-                    { propertyName: "target", propertyType: "string" },
-                ],
-            };
-            const eventProperties = [
-                { propertyName: "target", propertyType: "string" },
-                { propertyName: "extraProp", propertyType: "int" },
-                { propertyName: "anotherExtra", propertyType: "boolean" },
-            ];
-            const results = validator.validate(spec, eventProperties, "evt-extra");
-            // Only spec properties get results — extra properties are not reported
-            expect(results).toHaveLength(1);
-            expect(results[0].propertyName).toBe("target");
-            expect(results.find((r) => r.propertyName === "extraProp")).toBeUndefined();
-            expect(results.find((r) => r.propertyName === "anotherExtra")).toBeUndefined();
-        });
-    });
-    describe("bandwidth optimization", () => {
-        test("returns passedEventIds only when strictly smaller than failedEventIds", () => {
-            const spec = {
-                eventName: "click",
-                properties: [{ propertyName: "target", propertyType: "string" }],
-            };
-            // Single pass
-            const passResults = validator.validate(spec, [{ propertyName: "target", propertyType: "string" }], "evt-pass");
-            const passResult = passResults.find((r) => r.propertyName === "target");
-            // When there's only passed and no failed, passedEventIds count (1) > failedEventIds count (0)
-            // So passedEventIds is NOT strictly smaller - it should be returned
-            // But the optimization says: return passedEventIds ONLY when strictly smaller than failedEventIds
-            // So when passedEventIds.length >= failedEventIds.length, we clear passedEventIds
-            expect(passResult === null || passResult === void 0 ? void 0 : passResult.passedEventIds).toEqual([]);
-            // Single fail
-            const failResults = validator.validate(spec, [{ propertyName: "target", propertyType: "int" }], "evt-fail");
-            const failResult = failResults.find((r) => r.propertyName === "target");
-            // failedEventIds has 1, passedEventIds has 0 -> passedEventIds is strictly smaller, return it
-            expect(failResult === null || failResult === void 0 ? void 0 : failResult.failedEventIds).toContain("evt-fail");
-        });
-    });
-});

package/dist/__tests__/TestNetworkCallsHandler.d.ts

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

package/dist/__tests__/TestNetworkCallsHandler.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoGuid_1 = require("../AvoGuid");
-const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
-const constants_1 = require("./constants");
-const inspectorVersion = process.env.npm_package_version || "";
-describe("NetworkCallsHandler", () => {
-    const { apiKey, env, version } = constants_1.defaultOptions;
-    const appName = "";
-    let networkHandler;
-    let baseBody;
-    const now = new Date();
-    beforeAll(() => {
-        // @ts-ignore
-        jest.spyOn(global, "Date").mockImplementation(() => now);
-        jest
-            .spyOn(AvoGuid_1.AvoGuid, "newGuid")
-            .mockImplementation(() => constants_1.mockedReturns.GUID);
-        networkHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(apiKey, env, "", version, inspectorVersion);
-        baseBody = {
-            apiKey,
-            appName,
-            appVersion: version,
-            libVersion: inspectorVersion,
-            env,
-            libPlatform: "node",
-            messageId: constants_1.mockedReturns.GUID,
-            trackingId: "",
-            sessionId: "",
-            anonymousId: "",
-            createdAt: new Date().toISOString(),
-            samplingRate: 1.0,
-        };
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    test("bodyForEventSchemaCall returns base body + event schema used for event sending from non Codegen", () => {
-        const eventName = "event name";
-        const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-        const body = networkHandler.bodyForEventSchemaCall("", eventName, eventProperties, null, null);
-        expect(body).toEqual(Object.assign(Object.assign({}, baseBody), { anonymousId: "", type: "event", eventName,
-            eventProperties, avoFunction: false, eventId: null, eventHash: null }));
-    });
-    test("bodyForEventSchemaCall returns base body + event schema used for event sending from Codegen", () => {
-        const eventName = "event name";
-        const eventId = "event id";
-        const eventHash = "event hash";
-        const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-        const body = networkHandler.bodyForEventSchemaCall("", eventName, eventProperties, eventId, eventHash);
-        expect(body).toEqual(Object.assign(Object.assign({}, baseBody), { anonymousId: "", type: "event", eventName,
-            eventProperties, avoFunction: true, eventId,
-            eventHash }));
-    });
-    test("bodyForEventSchemaCall uses streamId as anonymousId", () => {
-        const eventName = "event name";
-        const streamId = "user-123";
-        const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-        const body = networkHandler.bodyForEventSchemaCall(streamId, eventName, eventProperties, null, null);
-        expect(body.anonymousId).toBe("user-123");
-    });
-    test("bodyForEventSchemaCall with rawEventProperties passes them through (no encryption in dev without key)", () => {
-        const eventName = "event name";
-        const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-        const rawEventProperties = { prop0: "hello" };
-        const body = networkHandler.bodyForEventSchemaCall("", eventName, eventProperties, null, null, rawEventProperties);
-        // Without a publicEncryptionKey, encryption is not triggered,
-        // so eventProperties should be the plain schema (not encrypted)
-        expect(body.eventProperties).toEqual(eventProperties);
-        expect(body.type).toBe("event");
-        expect(body.eventName).toBe(eventName);
-    });
-    test("base body includes publicEncryptionKey when handler is constructed with one", () => {
-        const handlerWithKey = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(apiKey, env, "", version, inspectorVersion, "test-public-key-abc");
-        const eventName = "event name";
-        const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-        const body = handlerWithKey.bodyForEventSchemaCall("", eventName, eventProperties, null, null);
-        expect(body.publicEncryptionKey).toBe("test-public-key-abc");
-    });
-    test("base body does not include publicEncryptionKey when handler is constructed without one", () => {
-        const eventName = "event name";
-        const eventProperties = [{ propertyName: "prop0", propertyType: "string" }];
-        const body = networkHandler.bodyForEventSchemaCall("", eventName, eventProperties, null, null);
-        expect(body.publicEncryptionKey).toBeUndefined();
-    });
-});

package/dist/__tests__/TestNetworkCallsHandlerPublic.d.ts

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

package/dist/__tests__/TestNetworkCallsHandlerPublic.js

@@ -1,160 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoInspector_1 = require("../AvoInspector");
-const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
-const constants_1 = require("./constants");
-describe("AvoNetworkCallsHandler", () => {
-    let inspectorCallSpy;
-    let consoleLogSpy;
-    let inspector;
-    const { apiKey, env, version, appName } = constants_1.defaultOptions;
-    const eventName = "event name";
-    const properties = {
-        prop0: "",
-        prop2: false,
-        prop3: 0,
-        prop4: 0.0,
-    };
-    const happyPathInspectorCall = () => {
-        return Promise.resolve();
-    };
-    beforeAll(() => {
-        inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(true);
-        inspectorCallSpy = jest
-            .spyOn(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.prototype, "callInspectorWithBatchBody");
-        consoleLogSpy = jest.spyOn(console, "log").mockImplementation(() => { });
-    });
-    beforeEach(() => {
-        inspectorCallSpy.mockImplementation(happyPathInspectorCall);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-        // @ts-ignore
-        inspector.avoDeduplicator._clearEvents();
-    });
-    test("trackSchemaFromEvent sends only event call (no sessionStarted)", () => __awaiter(void 0, void 0, void 0, function* () {
-        yield inspector.trackSchemaFromEvent(eventName, properties);
-        // Should be called once (event only, no sessionStarted)
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
-            expect.objectContaining({
-                type: "event",
-                apiKey: apiKey,
-                appName: appName,
-                appVersion: version,
-                libVersion: expect.anything(),
-                env: env,
-                libPlatform: "node",
-                messageId: expect.anything(),
-                anonymousId: "",
-                createdAt: expect.any(String),
-                samplingRate: 1,
-            }),
-        ]);
-    }));
-    test("trackSchemaFromEvent with streamId sets anonymousId to streamId", () => __awaiter(void 0, void 0, void 0, function* () {
-        yield inspector.trackSchemaFromEvent(eventName, properties, "user-stream-123");
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
-            expect.objectContaining({
-                type: "event",
-                anonymousId: "user-stream-123",
-            }),
-        ]);
-    }));
-    test("trackSchemaFromEvent without streamId sets anonymousId to empty string", () => __awaiter(void 0, void 0, void 0, function* () {
-        yield inspector.trackSchemaFromEvent(eventName, properties);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
-            expect.objectContaining({
-                anonymousId: "",
-            }),
-        ]);
-    }));
-    test("trackSchemaFromEvent with streamId containing ':' logs warning", () => __awaiter(void 0, void 0, void 0, function* () {
-        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
-        yield inspector.trackSchemaFromEvent(eventName, properties, "invalid:stream");
-        expect(consoleWarnSpy).toHaveBeenCalledWith("[Avo Inspector] Warning: streamId contains ':' which is not supported");
-        consoleWarnSpy.mockRestore();
-    }));
-    test("_avoFunctionTrackSchemaFromEvent sends only event call (no sessionStarted)", () => __awaiter(void 0, void 0, void 0, function* () {
-        const eventId = "testId";
-        const eventHash = "testHash";
-        // @ts-ignore
-        yield inspector._avoFunctionTrackSchemaFromEvent(eventName, properties, eventId, eventHash);
-        // Should be called once (event only, no sessionStarted)
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
-            expect.objectContaining({
-                type: "event",
-                apiKey: apiKey,
-                appName: appName,
-                appVersion: version,
-                libVersion: expect.anything(),
-                env: env,
-                libPlatform: "node",
-                messageId: expect.anything(),
-                anonymousId: "",
-                createdAt: expect.any(String),
-            }),
-        ]);
-    }));
-    test("an error is logged if event schema call fails and AvoInspector.shouldLog is true", () => __awaiter(void 0, void 0, void 0, function* () {
-        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        inspectorCallSpy.mockRejectedValueOnce('Network error');
-        yield inspector.trackSchemaFromEvent(eventName, properties);
-        expect(consoleErrorSpy).toHaveBeenCalledWith('Avo Inspector: schema sending failed: Network error.');
-        consoleErrorSpy.mockRestore();
-    }));
-    test("_avoFunctionTrackSchemaFromEvent passes empty string as anonymousId", () => __awaiter(void 0, void 0, void 0, function* () {
-        const eventId = "testId";
-        const eventHash = "testHash";
-        // @ts-ignore
-        yield inspector._avoFunctionTrackSchemaFromEvent(eventName, properties, eventId, eventHash);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
-            expect.objectContaining({
-                anonymousId: "",
-            }),
-        ]);
-    }));
-    test("trackSchemaFromEvent with streamId containing ':' still sends the event", () => __awaiter(void 0, void 0, void 0, function* () {
-        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
-        yield inspector.trackSchemaFromEvent(eventName, properties, "bad:stream");
-        // Warning is logged
-        expect(consoleWarnSpy).toHaveBeenCalledWith("[Avo Inspector] Warning: streamId contains ':' which is not supported");
-        // Event is still sent despite the warning
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(1);
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledWith([
-            expect.objectContaining({
-                type: "event",
-                anonymousId: "bad:stream",
-            }),
-        ]);
-        consoleWarnSpy.mockRestore();
-    }));
-    test("same event with different streamIds is not deduplicated", () => __awaiter(void 0, void 0, void 0, function* () {
-        yield inspector.trackSchemaFromEvent(eventName, properties, "stream-a");
-        yield inspector.trackSchemaFromEvent(eventName, properties, "stream-b");
-        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
-    }));
-    test("trackSchemaFromEvent rejection contains the expected error string", () => __awaiter(void 0, void 0, void 0, function* () {
-        const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => { });
-        // Force the catch block in trackSchemaFromEvent by making extractSchema throw
-        jest.spyOn(inspector, "extractSchema").mockImplementation(() => {
-            throw new Error("test explosion");
-        });
-        yield expect(inspector.trackSchemaFromEvent(eventName, properties)).rejects.toBe("Avo Inspector: something went wrong. Please report to support@avo.app.");
-        consoleErrorSpy.mockRestore();
-        inspector.extractSchema.mockRestore();
-    }));
-});

package/dist/__tests__/TestParsing.d.ts

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

package/dist/__tests__/TestParsing.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoInspector_1 = require("../AvoInspector");
-const constants_1 = require("./constants");
-describe("Schema Parsing", () => {
-    const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-    beforeAll(() => {
-        inspector.enableLogging(false);
-    });
-    test("Empty array returned if eventProperties are not set", () => {
-        // @ts-ignore
-        const schema = inspector.extractSchema();
-        expect(schema).toEqual([]);
-    });
-    test("Property types and names are set", () => {
-        // Given
-        const eventProperties = {
-            prop0: true,
-            prop1: 1,
-            prop2: "str",
-            prop3: 0.5,
-            prop4: undefined,
-            prop5: null,
-            prop6: { an: "object" },
-            prop7: [
-                "a",
-                "list",
-                {
-                    "obj in list": true,
-                    "int field": 1,
-                },
-                ["another", "list"],
-                [1, 2],
-            ],
-        };
-        // When
-        const res = inspector.extractSchema(eventProperties);
-        // Then
-        res.forEach(({ propertyName }, index) => {
-            expect(propertyName).toBe(`prop${index}`);
-        });
-        expect(res[0].propertyType).toBe(constants_1.type.BOOL);
-        expect(res[1].propertyType).toBe(constants_1.type.INT);
-        expect(res[2].propertyType).toBe(constants_1.type.STRING);
-        expect(res[3].propertyType).toBe(constants_1.type.FLOAT);
-        expect(res[4].propertyType).toBe(constants_1.type.NULL);
-        expect(res[5].propertyType).toBe(constants_1.type.NULL);
-        expect(res[6].propertyType).toBe(constants_1.type.OBJECT);
-        expect(res[6].children).toMatchObject([
-            {
-                propertyName: "an",
-                propertyType: constants_1.type.STRING,
-            },
-        ]);
-        expect(res[7].propertyType).toBe(constants_1.type.STRINGLIST);
-        expect(res[7].children).toMatchObject([
-            constants_1.type.STRING,
-            [
-                {
-                    propertyName: "obj in list",
-                    propertyType: constants_1.type.BOOL,
-                },
-                {
-                    propertyName: "int field",
-                    propertyType: constants_1.type.INT,
-                },
-            ],
-            [constants_1.type.STRING],
-            [constants_1.type.INT],
-        ]);
-    });
-    test("Duplicated values are removed", () => {
-        // Given
-        const eventProperties = {
-            prop0: ["true", "false", true, 10, "true", true, 11, 10, 0.1, 0.1],
-        };
-        // When
-        const res = inspector.extractSchema(eventProperties);
-        // Then
-        expect(res[0].propertyType).toBe(constants_1.type.STRINGLIST);
-    });
-    test("Empty and falsy values are set correctly", () => {
-        // Given
-        const eventProperties = {
-            prop0: false,
-            prop1: 0,
-            prop2: "",
-            prop3: 0.0,
-            prop4: undefined,
-            prop5: null,
-            prop6: {},
-            prop7: [],
-        };
-        // When
-        const res = inspector.extractSchema(eventProperties);
-        // Then
-        expect(res[0].propertyType).toBe(constants_1.type.BOOL);
-        expect(res[1].propertyType).toBe(constants_1.type.INT);
-        expect(res[2].propertyType).toBe(constants_1.type.STRING);
-        expect(res[3].propertyType).toBe(constants_1.type.INT);
-        expect(res[4].propertyType).toBe(constants_1.type.NULL);
-        expect(res[5].propertyType).toBe(constants_1.type.NULL);
-        expect(res[6].propertyType).toBe(constants_1.type.OBJECT);
-        expect(res[6].children).toMatchObject([]);
-        expect(res[7].propertyType).toBe(constants_1.type.STRINGLIST);
-        expect(res[7].children).toMatchObject([]);
-    });
-    test("List of string returns list(string)", () => {
-        // Given
-        const eventProperties = {
-            prop0: ["a", "b", "c"],
-        };
-        // When
-        const res = inspector.extractSchema(eventProperties);
-        // Then
-        expect(res[0].propertyType).toBe(constants_1.type.STRINGLIST);
-    });
-    test("List of multiple types returns list(`firstType`)", () => {
-        // Given
-        const eventProperties = {
-            prop0: [1.2, "two", { "three": 3 }],
-        };
-        // When
-        const res = inspector.extractSchema(eventProperties);
-        // Then
-        expect(res[0].propertyType).toBe(constants_1.type.FLOATLIST);
-    });
-});

package/dist/__tests__/constants.d.ts

@@ -1,42 +0,0 @@
-declare const defaultOptions: {
-    apiKey: string;
-    env: "dev";
-    version: string;
-    shouldLog: boolean;
-    appName: string;
-};
-declare const error: {
-    API_KEY: string;
-    VERSION: string;
-};
-declare const mockedReturns: {
-    INSTALLATION_ID: string;
-    GUID: string;
-    SESSION_ID: string;
-};
-declare const networkCallType: {
-    EVENT: string;
-    SESSION_STARTED: string;
-};
-declare const requestMsg: {
-    ERROR: string;
-    TIMEOUT: string;
-};
-declare const trackingEndpoint = "https://api.avo.app/inspector/v1/track";
-declare const sessionTimeMs: number;
-declare const type: {
-    STRING: string;
-    STRINGLIST: string;
-    INT: string;
-    INTLIST: string;
-    OBJECT: string;
-    OBJECTLIST: string;
-    FLOAT: string;
-    FLOATLIST: string;
-    BOOL: string;
-    BOOLLIST: string;
-    NULL: string;
-    UNKNOWN: string;
-    UNKNOWNLIST: string;
-};
-export { defaultOptions, error, mockedReturns, networkCallType, requestMsg, sessionTimeMs, type, trackingEndpoint, };