node-avo-inspector 1.0.1 → 1.1.0

package/README.md

@@ -1,6 +1,8 @@
 # Avo Inspector SDK for Node.js
 
-This is a quick start guide. For more information about the Inspector project please read [Avo Inspector SDK Reference](https://www.avo.app/docs/implementation/avo-inspector-sdk-reference) and the [Avo Inspector Setup Guide](https://www.avo.app/docs/implementation/setup-inspector-sdk).
+[![npm version](https://badge.fury.io/js/node-avo-inspector.svg)](https://badge.fury.io/js/node-avo-inspector)
+
+This is a quick start guide. For more information about the Inspector project please read the [Inspector SDK Reference](https://www.avo.app/docs/implementation/avo-inspector-sdk-reference) and the [Inspector Setup Guide](https://www.avo.app/docs/implementation/setup-inspector-sdk).
 
 # Installation
 
@@ -29,12 +31,19 @@ let inspector = new Inspector.AvoInspector({
 });
 ```
 
-# Sending event schemas
+# Integrating with Avo Codegen
+
+The setup is lightweight and is covered [in this guide](https://www.avo.app/docs/implementation/start-using-inspector-with-avo-functions).
+
+Every event sent with your Codegen after this integration will automatically be sent to Inspector.
+
+# Sending event schemas for events reported outside of Codegen
+
+Whenever you send tracking event call the following methods:
 
-Whenever you send tracking event call the following method:
-Read more in the [Avo documentation](https://www.avo.app/docs/implementation/inspector/sdk/node)
+Read more in the [Avo documentation](https://www.avo.app/docs/implementation/devs-101#inspecting-events)
 
-This method gets actual tracking event parameters, extracts schema automatically and sends it to the Avo Inspector backend.
+This method gets actual tracking event parameters, extracts schema automatically and sends it to the Inspector backend.
 It is the easiest way to use the library, just call this method at the same place you call your analytics tools' track methods with the same parameters.
 
 ```javascript

package/dist/AvoDeduplicator.js

@@ -46,7 +46,7 @@ class AvoDeduplicator {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
                 if (otherEventName === eventName) {
                     const otherParams = eventsStorage[eventName];
-                    if (otherParams && utils_1.deepEquals(params, otherParams)) {
+                    if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
                         return true;
                     }
                 }
@@ -72,7 +72,7 @@ class AvoDeduplicator {
         for (const otherEventName in eventsStorage) {
             if (eventsStorage.hasOwnProperty(otherEventName)) {
                 const otherParams = eventsStorage[otherEventName];
-                if (otherParams && utils_1.deepEquals(params, otherParams)) {
+                if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
                     return true;
                 }
             }

package/dist/AvoInspector.d.ts

@@ -1,9 +1,9 @@
 import { AvoInspectorEnvValueType } from "./AvoInspectorEnv";
-import { AvoBatcher } from "./AvoBatcher";
+import { AvoNetworkCallsHandler } from "./AvoNetworkCallsHandler";
 import { AvoDeduplicator } from "./AvoDeduplicator";
 export declare class AvoInspector {
     environment: AvoInspectorEnvValueType;
-    avoBatcher: AvoBatcher;
+    avoNetworkCallsHandler: AvoNetworkCallsHandler;
     avoDeduplicator: AvoDeduplicator;
     apiKey: string;
     version: string;

package/dist/AvoInspector.js

@@ -3,15 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoInspector = void 0;
 const AvoInspectorEnv_1 = require("./AvoInspectorEnv");
 const AvoSchemaParser_1 = require("./AvoSchemaParser");
-const AvoBatcher_1 = require("./AvoBatcher");
 const AvoNetworkCallsHandler_1 = require("./AvoNetworkCallsHandler");
 const AvoDeduplicator_1 = require("./AvoDeduplicator");
 const utils_1 = require("./utils");
+const AvoGuid_1 = require("./AvoGuid");
 const libVersion = require("../package.json").version;
 class AvoInspector {
+    static get shouldLog() {
+        return this._shouldLog;
+    }
+    static set shouldLog(enable) {
+        this._shouldLog = enable;
+    }
     constructor(options) {
         // the constructor does aggressive null/undefined checking because same code paths will be accessible from JS
-        if (utils_1.isValueEmpty(options.env)) {
+        if ((0, utils_1.isValueEmpty)(options.env)) {
             this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
             console.warn("[Avo Inspector] No environment provided. Defaulting to dev.");
         }
@@ -22,13 +28,13 @@ class AvoInspector {
         else {
             this.environment = options.env;
         }
-        if (utils_1.isValueEmpty(options.apiKey)) {
+        if ((0, utils_1.isValueEmpty)(options.apiKey)) {
             throw new Error("[Avo Inspector] No API key provided. Inspector can't operate without API key.");
         }
         else {
             this.apiKey = options.apiKey;
         }
-        if (utils_1.isValueEmpty(options.version)) {
+        if ((0, utils_1.isValueEmpty)(options.version)) {
             throw new Error("[Avo Inspector] No version provided. Many features of Inspector rely on versioning. Please provide comparable string version, i.e. integer or semantic.");
         }
         else {
@@ -40,16 +46,9 @@ class AvoInspector {
         else {
             AvoInspector._shouldLog = false;
         }
-        let avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion);
-        this.avoBatcher = new AvoBatcher_1.AvoBatcher(avoNetworkCallsHandler);
+        this.avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion);
         this.avoDeduplicator = new AvoDeduplicator_1.AvoDeduplicator();
     }
-    static get shouldLog() {
-        return this._shouldLog;
-    }
-    static set shouldLog(enable) {
-        this._shouldLog = enable;
-    }
     trackSchemaFromEvent(eventName, eventProperties) {
         try {
             if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, false)) {
@@ -104,7 +103,28 @@ class AvoInspector {
     }
     trackSchemaInternal(eventName, eventSchema, eventId, eventHash) {
         try {
-            return this.avoBatcher.handleTrackSchema(eventName, eventSchema, eventId, eventHash);
+            const seesionId = AvoGuid_1.AvoGuid.newGuid();
+            return this.avoNetworkCallsHandler
+                .callInspectorWithBatchBody([
+                this.avoNetworkCallsHandler.bodyForSessionStartedCall(seesionId),
+            ])
+                .then(() => {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: session started sent successfully.");
+                }
+                this.avoNetworkCallsHandler.callInspectorWithBatchBody([
+                    this.avoNetworkCallsHandler.bodyForEventSchemaCall(seesionId, eventName, eventSchema, eventId, eventHash),
+                ]).then(() => {
+                    if (AvoInspector.shouldLog) {
+                        console.log("Avo Inspector: schema sent successfully.");
+                    }
+                });
+            })
+                .catch((err) => {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: schema sending failed: " + err + ".");
+                }
+            });
         }
         catch (e) {
             console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
@@ -118,7 +138,7 @@ class AvoInspector {
         try {
             if (this.avoDeduplicator.hasSeenEventParams(eventProperties, true)) {
                 if (shouldLogIfEnabled && AvoInspector.shouldLog) {
-                    console.warn("Avo Inspector: WARNING! You are trying to extract schema shape that was just reported by your Avo functions. " +
+                    console.warn("Avo Inspector: WARNING! You are trying to extract schema shape that was just reported by your Codegen. " +
                         "This is an indicator of duplicate inspector reporting. " +
                         "Please reach out to support@avo.app for advice if you are not sure how to handle this.");
                 }

package/dist/AvoInspectorEnv.d.ts

@@ -3,5 +3,5 @@ export declare const AvoInspectorEnv: {
     readonly Dev: "dev";
     readonly Staging: "staging";
 };
-export declare type AvoInspectorEnvType = typeof AvoInspectorEnv;
-export declare type AvoInspectorEnvValueType = AvoInspectorEnvType[keyof AvoInspectorEnvType];
+export type AvoInspectorEnvType = typeof AvoInspectorEnv;
+export type AvoInspectorEnvValueType = AvoInspectorEnvType[keyof AvoInspectorEnvType];

package/dist/AvoNetworkCallsHandler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoNetworkCallsHandler = void 0;
 const AvoGuid_1 = require("./AvoGuid");
 const AvoInspector_1 = require("./AvoInspector");
+const https_1 = require("https");
 class AvoNetworkCallsHandler {
     constructor(apiKey, envName, appName, appVersion, libVersion) {
         this.samplingRate = 1.0;
@@ -49,7 +50,7 @@ class AvoNetworkCallsHandler {
                     "Content-Length": Buffer.byteLength(data),
                 },
             };
-            var req = require("https").request(options, (res) => {
+            var req = (0, https_1.request)(options, (res) => {
                 const chunks = [];
                 res.on("data", (data) => chunks.push(data));
                 res.on("end", () => {

package/dist/AvoSchemaParser.d.ts

@@ -7,5 +7,6 @@ export declare class AvoSchemaParser {
         children?: any;
     }>;
     private static removeDuplicates;
+    private static getBasicPropType;
     private static getPropValueType;
 }

package/dist/AvoSchemaParser.js

@@ -56,7 +56,7 @@ class AvoSchemaParser {
             }
         });
     }
-    static getPropValueType(propValue) {
+    static getBasicPropType(propValue) {
         let propType = typeof propValue;
         if (propValue == null) {
             return "null";
@@ -76,15 +76,26 @@ class AvoSchemaParser {
             return "boolean";
         }
         else if (propType === "object") {
-            if (isArray(propValue)) {
-                return "list";
+            return "object";
+        }
+        else {
+            return "unknown";
+        }
+    }
+    static getPropValueType(propValue) {
+        if (isArray(propValue)) {
+            //we now know that propValue is an array. get first element in propValue array
+            let propElement = propValue[0];
+            if (propElement == null) {
+                return "list(string)"; // Default to list(string) if the list is empty.
             }
             else {
-                return "object";
+                let propElementType = this.getBasicPropType(propElement);
+                return `list(${propElementType})`;
             }
         }
         else {
-            return "unknown";
+            return this.getBasicPropType(propValue);
         }
     }
 }

package/dist/__tests__/TestAvoInspector.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const AvoInspector_1 = require("../AvoInspector");
 const AvoInspectorEnv_1 = require("../AvoInspectorEnv");
 const constants_1 = require("./constants");
+const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
+jest.mock("../AvoNetworkCallsHandler");
 describe("Initialization", () => {
+    test("Network Handler is initialized on Inspector init", () => {
+        const inspectorVersion = process.env.npm_package_version || "";
+        const { apiKey, env, version, appName } = constants_1.defaultOptions;
+        let inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
+        inspector.enableLogging(true);
+        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledTimes(1);
+        expect(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler).toHaveBeenCalledWith(apiKey, env, "my-test-app", version, inspectorVersion);
+    });
     test("Api Key is set", () => {
         // Given
         const apiKey = "api-key-xxx";

package/dist/__tests__/TestDeduplicator.js

@@ -28,10 +28,10 @@ describe("Deduplicator", () => {
             2: [["str", true]],
             3: { avo: [1.1, 2.2, 3.3] },
         };
-        expect(utils_1.deepEquals(testObject, secondObject)).toBe(true);
-        expect(utils_1.deepEquals(testObject, Object.assign(Object.assign({}, secondObject), { "4": "4" }))).toBe(false);
-        expect(utils_1.deepEquals(testObject, Object.assign(Object.assign({}, secondObject), { 3: Object.assign(Object.assign({}, secondObject[3]), { avo: [1.1] }) }))).toBe(false);
-        expect(utils_1.deepEquals(testObject, Object.assign(Object.assign({}, secondObject), { 0: "other string" }))).toBe(false);
+        expect((0, utils_1.deepEquals)(testObject, secondObject)).toBe(true);
+        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { "4": "4" }))).toBe(false);
+        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { 3: Object.assign(Object.assign({}, secondObject[3]), { avo: [1.1] }) }))).toBe(false);
+        expect((0, utils_1.deepEquals)(testObject, Object.assign(Object.assign({}, secondObject), { 0: "other string" }))).toBe(false);
     });
     test(`Detects duplications when track in avo and then manually`, () => {
         const shouldRegisterFromAvo = deduplicator.shouldRegisterEvent("Test", testObject, true);
@@ -53,8 +53,7 @@ describe("Deduplicator", () => {
         const avoTrackedSchema = yield inspector._avoFunctionTrackSchemaFromEvent("test", testObject, "eventId", "eventhash");
         const manuallyTrackedSchemaAgain = yield inspector.trackSchemaFromEvent("test", testObject);
         expect(manuallyTrackedSchema.length).toBe(4);
-        expect(avoTrackedSchema.length).toBe(0);
-        expect(manuallyTrackedSchemaAgain.length).toBe(4);
+        expect(manuallyTrackedSchema.length + avoTrackedSchema.length + manuallyTrackedSchemaAgain.length).toBe(8);
     }));
     test(`Inspector deduplicates only one event when track in avo, manually and then in avo again`, () => __awaiter(void 0, void 0, void 0, function* () {
         const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);

package/dist/__tests__/TestNetworkCallsHandler.js

@@ -39,14 +39,14 @@ describe("NetworkCallsHandler", () => {
         const body = networkHandler.bodyForSessionStartedCall(constants_1.mockedReturns.SESSION_ID);
         expect(body).toEqual(Object.assign(Object.assign({}, baseBody), { type: "sessionStarted" }));
     });
-    test("bodyForEventSchemaCall returns base body + event schema used for event sending from non avo functions", () => {
+    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(constants_1.mockedReturns.SESSION_ID, eventName, eventProperties, null, null);
         expect(body).toEqual(Object.assign(Object.assign({}, baseBody), { type: "event", eventName,
             eventProperties, avoFunction: false, eventId: null, eventHash: null }));
     });
-    test("bodyForEventSchemaCall returns base body + event schema used for event sending from avo functions", () => {
+    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";

package/dist/__tests__/TestNetworkCallsHandlerPublic.js

@@ -0,0 +1,125 @@
+"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 inspector;
+    const { apiKey, env, version, appName } = constants_1.defaultOptions;
+    beforeAll(() => {
+        inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
+        inspector.enableLogging(false);
+        inspectorCallSpy = jest
+            .spyOn(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.prototype, "callInspectorWithBatchBody");
+        inspectorCallSpy.mockImplementation(() => {
+            inspector.avoNetworkCallsHandler["samplingRate"] = 0.1;
+            return Promise.resolve();
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+        // @ts-ignore
+        inspector.avoDeduplicator._clearEvents();
+    });
+    test("handleTrackSchema is called on trackSchemaFromEvent", () => __awaiter(void 0, void 0, void 0, function* () {
+        const eventName = "event name";
+        const properties = {
+            prop0: "",
+            prop2: false,
+            prop3: 0,
+            prop4: 0.0,
+        };
+        const schema = inspector.extractSchema(properties);
+        yield inspector.trackSchemaFromEvent(eventName, properties);
+        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
+        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toBeCalledWith([
+            expect.objectContaining({
+                type: "sessionStarted",
+                apiKey: apiKey,
+                appName: appName,
+                appVersion: version,
+                libVersion: expect.anything(),
+                env: env,
+                libPlatform: "node",
+                messageId: expect.anything(),
+                trackingId: "",
+                createdAt: expect.any(String),
+                sessionId: expect.anything(),
+                samplingRate: 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(),
+                trackingId: "",
+                createdAt: expect.anything(),
+                sessionId: expect.anything(),
+                samplingRate: 0.1,
+            }),
+        ]);
+    }));
+    test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", () => __awaiter(void 0, void 0, void 0, function* () {
+        const eventName = "event name";
+        const properties = {
+            prop0: "",
+            prop2: false,
+            prop3: 0,
+            prop4: 0.0,
+        };
+        const eventId = "testId";
+        const eventHash = "testHash";
+        const schema = inspector.extractSchema(properties);
+        // @ts-ignore
+        yield inspector._avoFunctionTrackSchemaFromEvent(eventName, properties, eventId, eventHash);
+        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toHaveBeenCalledTimes(2);
+        expect(inspector.avoNetworkCallsHandler.callInspectorWithBatchBody).toBeCalledWith([
+            expect.objectContaining({
+                type: "sessionStarted",
+                apiKey: apiKey,
+                appName: appName,
+                appVersion: version,
+                libVersion: expect.anything(),
+                env: env,
+                libPlatform: "node",
+                messageId: expect.anything(),
+                trackingId: "",
+                createdAt: expect.anything(),
+                sessionId: expect.anything(),
+                samplingRate: 0.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(),
+                trackingId: "",
+                createdAt: expect.anything(),
+                sessionId: expect.anything(),
+                samplingRate: 0.1,
+            }),
+        ]);
+    }));
+});

package/dist/__tests__/TestParsing.js

@@ -52,7 +52,7 @@ describe("Schema Parsing", () => {
                 propertyType: constants_1.type.STRING,
             },
         ]);
-        expect(res[7].propertyType).toBe(constants_1.type.LIST);
+        expect(res[7].propertyType).toBe(constants_1.type.STRINGLIST);
         expect(res[7].children).toMatchObject([
             constants_1.type.STRING,
             [
@@ -77,13 +77,7 @@ describe("Schema Parsing", () => {
         // When
         const res = inspector.extractSchema(eventProperties);
         // Then
-        expect(res[0].propertyType).toBe(constants_1.type.LIST);
-        expect(res[0].children).toMatchObject([
-            constants_1.type.STRING,
-            constants_1.type.BOOL,
-            constants_1.type.INT,
-            constants_1.type.FLOAT,
-        ]);
+        expect(res[0].propertyType).toBe(constants_1.type.STRINGLIST);
     });
     test("Empty and falsy values are set correctly", () => {
         // Given
@@ -108,7 +102,27 @@ describe("Schema Parsing", () => {
         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.LIST);
+        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

@@ -26,12 +26,17 @@ 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;
-    LIST: string;
+    FLOATLIST: string;
     BOOL: string;
+    BOOLLIST: string;
     NULL: string;
     UNKNOWN: string;
+    UNKNOWNLIST: string;
 };
 export { defaultOptions, error, mockedReturns, networkCallType, requestMsg, sessionTimeMs, type, trackingEndpoint, };

package/dist/__tests__/constants.js

@@ -37,12 +37,17 @@ const sessionTimeMs = 5 * 60 * 1000;
 exports.sessionTimeMs = sessionTimeMs;
 const type = {
     STRING: "string",
+    STRINGLIST: "list(string)",
     INT: "int",
+    INTLIST: "list(int)",
     OBJECT: "object",
+    OBJECTLIST: "list(object)",
     FLOAT: "float",
-    LIST: "list",
+    FLOATLIST: "list(float)",
     BOOL: "boolean",
+    BOOLLIST: "list(boolean)",
     NULL: "null",
     UNKNOWN: "unknown",
+    UNKNOWNLIST: "list(unknown)",
 };
 exports.type = type;

package/dist/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepEquals = exports.isValueEmpty = void 0;
+exports.isValueEmpty = void 0;
+exports.deepEquals = deepEquals;
 const isValueEmpty = (value) => {
     return value === null || value === undefined || value.trim().length == 0;
 };
@@ -39,4 +40,3 @@ function deepEquals(x, y) {
     }
     return true;
 }
-exports.deepEquals = deepEquals;

package/examples/node-inspector-js/yarn.lock

@@ -3,4 +3,4 @@
 
 
 "node-avo-inspector@file:../..":
-  version "0.1.0"
+  version "1.0.4-beta.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-avo-inspector",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Avo Inspector for Node.js",
   "main": "dist/index.js",
   "repository": "https://github.com/avohq/node-avo-inspector",
@@ -36,11 +36,11 @@
     ]
   },
   "devDependencies": {
-    "@types/jest": "^26.0.15",
-    "@types/node": "^14.14.10",
-    "jest": "^26.6.3",
-    "ts-jest": "^26.4.4",
-    "typescript": "^4.1.2"
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.3.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.4",
+    "typescript": "*"
   },
   "dependencies": {}
 }