node-avo-inspector 1.0.1 → 1.0.3-beta.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/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,10 +3,10 @@ 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 {
     constructor(options) {
@@ -40,8 +40,7 @@ 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() {
@@ -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/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 = https_1.request(options, (res) => {
                 const chunks = [];
                 res.on("data", (data) => chunks.push(data));
                 res.on("end", () => {

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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-avo-inspector",
-  "version": "1.0.1",
+  "version": "1.0.3-beta.0",
   "description": "Avo Inspector for Node.js",
   "main": "dist/index.js",
   "repository": "https://github.com/avohq/node-avo-inspector",

package/src/AvoInspector.ts

@@ -1,16 +1,16 @@
 import { AvoInspectorEnv, AvoInspectorEnvValueType } from "./AvoInspectorEnv";
 import { AvoSchemaParser } from "./AvoSchemaParser";
-import { AvoBatcher } from "./AvoBatcher";
 import { AvoNetworkCallsHandler } from "./AvoNetworkCallsHandler";
 import { AvoDeduplicator } from "./AvoDeduplicator";
 
 import { isValueEmpty } from "./utils";
+import { AvoGuid } from "./AvoGuid";
 
 const libVersion = require("../package.json").version;
 
 export class AvoInspector {
   environment: AvoInspectorEnvValueType;
-  avoBatcher: AvoBatcher;
+  avoNetworkCallsHandler: AvoNetworkCallsHandler;
   avoDeduplicator: AvoDeduplicator;
   apiKey: string;
   version: string;
@@ -66,14 +66,13 @@ export class AvoInspector {
       AvoInspector._shouldLog = false;
     }
 
-    let avoNetworkCallsHandler = new AvoNetworkCallsHandler(
+    this.avoNetworkCallsHandler = new AvoNetworkCallsHandler(
       this.apiKey,
       this.environment.toString(),
       options.appName || "",
       this.version,
       libVersion
     );
-    this.avoBatcher = new AvoBatcher(avoNetworkCallsHandler);
     this.avoDeduplicator = new AvoDeduplicator();
   }
 
@@ -98,9 +97,9 @@ export class AvoInspector {
         if (AvoInspector.shouldLog) {
           console.log(
             "Avo Inspector: supplied event " +
-              eventName +
-              " with params " +
-              JSON.stringify(eventProperties)
+            eventName +
+            " with params " +
+            JSON.stringify(eventProperties)
           );
         }
         let eventSchema = this.extractSchema(eventProperties, false);
@@ -152,9 +151,9 @@ export class AvoInspector {
         if (AvoInspector.shouldLog) {
           console.log(
             "Avo Inspector: supplied event " +
-              eventName +
-              " with params " +
-              JSON.stringify(eventProperties)
+            eventName +
+            " with params " +
+            JSON.stringify(eventProperties)
           );
         }
         let eventSchema = this.extractSchema(eventProperties, false);
@@ -194,12 +193,34 @@ export class AvoInspector {
     eventHash: string | null
   ): Promise<void> {
     try {
-      return this.avoBatcher.handleTrackSchema(
-        eventName,
-        eventSchema,
-        eventId,
-        eventHash
-      );
+      const seesionId = 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.",
@@ -227,9 +248,9 @@ export class AvoInspector {
       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. " +
-              "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."
+            "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."
           );
         }
       }
@@ -237,7 +258,7 @@ export class AvoInspector {
       if (AvoInspector.shouldLog) {
         console.log(
           "Avo Inspector: extracting schema from " +
-            JSON.stringify(eventProperties)
+          JSON.stringify(eventProperties)
         );
       }
 

package/src/AvoNetworkCallsHandler.ts

@@ -1,5 +1,6 @@
 import { AvoGuid } from "./AvoGuid";
 import { AvoInspector } from "./AvoInspector";
+import { request } from "https";
 
 export interface BaseBody {
   apiKey: string;
@@ -102,7 +103,7 @@ export class AvoNetworkCallsHandler {
           "Content-Length": Buffer.byteLength(data),
         },
       };
-      var req = require("https").request(options, (res: any) => {
+      var req = request(options, (res: any) => {
         const chunks: any = [];
         res.on("data", (data: any) => chunks.push(data));
         res.on("end", () => {

package/src/__tests__/TestAvoInspector.ts

@@ -1,9 +1,28 @@
 import { AvoInspector } from "../AvoInspector";
 import { AvoInspectorEnv } from "../AvoInspectorEnv";
 
-import { error } from "./constants";
+import { error, defaultOptions } from "./constants";
+import { AvoNetworkCallsHandler } from "../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 } = defaultOptions;
+
+    let inspector = new AvoInspector(defaultOptions);
+    inspector.enableLogging(true);
+
+    expect(AvoNetworkCallsHandler).toHaveBeenCalledTimes(1);
+    expect(AvoNetworkCallsHandler).toHaveBeenCalledWith(apiKey,
+      env,
+      "my-test-app",
+      version,
+      inspectorVersion);
+  });
+
   test("Api Key is set", () => {
     // Given
     const apiKey = "api-key-xxx";

package/src/__tests__/TestDeduplicator.ts

@@ -1,6 +1,5 @@
 import { AvoDeduplicator } from "../AvoDeduplicator";
 import { deepEquals } from "../utils";
-import { AvoSchemaParser } from "../AvoSchemaParser";
 import { AvoInspector } from "../AvoInspector";
 import { defaultOptions } from "./constants";
 
@@ -91,8 +90,7 @@ describe("Deduplicator", () => {
     );
 
     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`, async () => {

package/src/__tests__/TestNetworkCallsHandler.ts

@@ -64,7 +64,7 @@ describe("NetworkCallsHandler", () => {
     });
   });
 
-  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" }];
 
@@ -87,7 +87,7 @@ describe("NetworkCallsHandler", () => {
     });
   });
 
-  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/src/__tests__/TestNetworkCallsHandlerPublic.ts

@@ -0,0 +1,137 @@
+import { AvoInspector } from "../AvoInspector";
+import { AvoNetworkCallsHandler } from "../AvoNetworkCallsHandler";
+
+import { defaultOptions } from "./constants";
+
+describe("AvoNetworkCallsHandler", () => {
+  let inspectorCallSpy: jest.SpyInstance<any, unknown[]>;
+
+  let inspector: AvoInspector;
+
+  const { apiKey, env, version, appName } = defaultOptions;
+
+  beforeAll(() => {
+    inspector = new AvoInspector(defaultOptions);
+    inspector.enableLogging(false);
+
+    inspectorCallSpy = jest
+      .spyOn(AvoNetworkCallsHandler.prototype as any, "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", async () => {
+    const eventName = "event name";
+    const properties = {
+      prop0: "",
+      prop2: false,
+      prop3: 0,
+      prop4: 0.0,
+    };
+
+    const schema = inspector.extractSchema(properties);
+
+    await 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", async () => {
+    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
+    await 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/AvoBatcher.d.ts

@@ -1,17 +0,0 @@
-import { AvoNetworkCallsHandler } from "./AvoNetworkCallsHandler";
-export interface AvoBatcherType {
-    handleTrackSchema(eventName: string, schema: Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>, eventId: string | null, eventHash: string | null): Promise<void>;
-}
-export declare class AvoBatcher implements AvoBatcherType {
-    private networkCallsHandler;
-    constructor(networkCallsHandler: AvoNetworkCallsHandler);
-    handleTrackSchema(eventName: string, schema: Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>, eventId: string | null, eventHash: string | null): Promise<void>;
-}

package/dist/AvoBatcher.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoBatcher = void 0;
-const AvoInspector_1 = require("./AvoInspector");
-const AvoGuid_1 = require("./AvoGuid");
-class AvoBatcher {
-    constructor(networkCallsHandler) {
-        this.networkCallsHandler = networkCallsHandler;
-    }
-    handleTrackSchema(eventName, schema, eventId, eventHash) {
-        const seeionId = AvoGuid_1.AvoGuid.newGuid();
-        return this.networkCallsHandler
-            .callInspectorWithBatchBody([
-            this.networkCallsHandler.bodyForSessionStartedCall(seeionId),
-        ])
-            .then(() => {
-            if (AvoInspector_1.AvoInspector.shouldLog) {
-                console.log("Avo Inspector: schema sent successfully.");
-            }
-            this.networkCallsHandler.callInspectorWithBatchBody([
-                this.networkCallsHandler.bodyForEventSchemaCall(seeionId, eventName, schema, eventId, eventHash),
-            ]);
-        })
-            .catch((err) => {
-            if (AvoInspector_1.AvoInspector.shouldLog) {
-                console.log("Avo Inspector: schema sending failed: " + err + ".");
-            }
-        });
-    }
-}
-exports.AvoBatcher = AvoBatcher;

package/dist/__tests__/TestBatcher.js

@@ -1,66 +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("Batcher", () => {
-    let inspectorCallSpy;
-    const { apiKey, env, version, shouldLog, appName } = constants_1.defaultOptions;
-    beforeAll(() => {
-        inspectorCallSpy = jest.spyOn(AvoNetworkCallsHandler_1.AvoNetworkCallsHandler.prototype, "callInspectorWithBatchBody");
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    test("handleTrackSchema sends session to AvoNetworkCallsHandler and then sends event respecting sampling rate", () => __awaiter(void 0, void 0, void 0, function* () {
-        const inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-        inspectorCallSpy.mockImplementation(() => {
-            inspector.avoBatcher["networkCallsHandler"]["samplingRate"] = 0.1;
-            return Promise.resolve();
-        });
-        yield inspector.avoBatcher.handleTrackSchema("event name", [], null, null);
-        expect(inspectorCallSpy).toHaveBeenCalledTimes(2);
-        expect(inspectorCallSpy).toHaveBeenCalledWith([
-            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: 1,
-            }),
-        ]);
-        expect(inspectorCallSpy).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__/TestBatcherPublic.d.ts

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

package/dist/__tests__/TestBatcherPublic.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AvoBatcher_1 = require("../AvoBatcher");
-const AvoInspector_1 = require("../AvoInspector");
-const AvoNetworkCallsHandler_1 = require("../AvoNetworkCallsHandler");
-const constants_1 = require("./constants");
-const inspectorVersion = process.env.npm_package_version || "";
-jest.mock("../AvoBatcher");
-describe("Batcher", () => {
-    let inspector;
-    const { apiKey, env, version } = constants_1.defaultOptions;
-    let networkHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(apiKey, env, "my-test-app", version, inspectorVersion);
-    beforeAll(() => {
-        inspector = new AvoInspector_1.AvoInspector(constants_1.defaultOptions);
-        inspector.enableLogging(false);
-        jest
-            .spyOn(AvoBatcher_1.AvoBatcher.prototype, "handleTrackSchema")
-            .mockImplementation(() => {
-            return Promise.resolve();
-        });
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-        // @ts-ignore
-        inspector.avoDeduplicator._clearEvents();
-    });
-    test("Batcher is initialized on Inspector init", () => {
-        expect(AvoBatcher_1.AvoBatcher).toHaveBeenCalledTimes(1);
-        expect(AvoBatcher_1.AvoBatcher).toHaveBeenCalledWith(networkHandler);
-    });
-    test("handleTrackSchema is called on trackSchemaFromEvent", () => {
-        const eventName = "event name";
-        const properties = {
-            prop0: "",
-            prop2: false,
-            prop3: 0,
-            prop4: 0.0,
-        };
-        const schema = inspector.extractSchema(properties);
-        inspector.trackSchemaFromEvent(eventName, properties);
-        expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-        expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(eventName, schema, null, null);
-    });
-    test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", () => {
-        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
-        inspector._avoFunctionTrackSchemaFromEvent(eventName, properties, eventId, eventHash);
-        expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-        expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(eventName, schema, eventId, eventHash);
-    });
-});

package/src/AvoBatcher.ts

@@ -1,60 +0,0 @@
-import { AvoNetworkCallsHandler } from "./AvoNetworkCallsHandler";
-import { AvoInspector } from "./AvoInspector";
-import { AvoGuid } from "./AvoGuid";
-
-export interface AvoBatcherType {
-  handleTrackSchema(
-    eventName: string,
-    schema: Array<{
-      propertyName: string;
-      propertyType: string;
-      children?: any;
-    }>,
-    eventId: string | null,
-    eventHash: string | null
-  ): Promise<void>;
-}
-
-export class AvoBatcher implements AvoBatcherType {
-  private networkCallsHandler: AvoNetworkCallsHandler;
-
-  constructor(networkCallsHandler: AvoNetworkCallsHandler) {
-    this.networkCallsHandler = networkCallsHandler;
-  }
-
-  handleTrackSchema(
-    eventName: string,
-    schema: Array<{
-      propertyName: string;
-      propertyType: string;
-      children?: any;
-    }>,
-    eventId: string | null,
-    eventHash: string | null
-  ): Promise<void> {
-    const seeionId = AvoGuid.newGuid();
-    return this.networkCallsHandler
-      .callInspectorWithBatchBody([
-        this.networkCallsHandler.bodyForSessionStartedCall(seeionId),
-      ])
-      .then(() => {
-        if (AvoInspector.shouldLog) {
-          console.log("Avo Inspector: schema sent successfully.");
-        }
-        this.networkCallsHandler.callInspectorWithBatchBody([
-          this.networkCallsHandler.bodyForEventSchemaCall(
-            seeionId,
-            eventName,
-            schema,
-            eventId,
-            eventHash
-          ),
-        ]);
-      })
-      .catch((err) => {
-        if (AvoInspector.shouldLog) {
-          console.log("Avo Inspector: schema sending failed: " + err + ".");
-        }
-      });
-  }
-}

package/src/__tests__/TestBatcher.ts

@@ -1,67 +0,0 @@
-import { AvoInspector } from "../AvoInspector";
-import { AvoNetworkCallsHandler } from "../AvoNetworkCallsHandler";
-
-import { defaultOptions } from "./constants";
-
-describe("Batcher", () => {
-  let inspectorCallSpy: jest.SpyInstance<any, unknown[]>;
-
-  const { apiKey, env, version, shouldLog, appName } = defaultOptions;
-
-  beforeAll(() => {
-    inspectorCallSpy = jest.spyOn(
-      AvoNetworkCallsHandler.prototype as any,
-      "callInspectorWithBatchBody"
-    );
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test("handleTrackSchema sends session to AvoNetworkCallsHandler and then sends event respecting sampling rate", async () => {
-    const inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
-
-    inspectorCallSpy.mockImplementation(() => {
-      inspector.avoBatcher["networkCallsHandler"]["samplingRate"] = 0.1;
-      return Promise.resolve();
-    });
-
-    await inspector.avoBatcher.handleTrackSchema("event name", [], null, null);
-
-    expect(inspectorCallSpy).toHaveBeenCalledTimes(2);
-    expect(inspectorCallSpy).toHaveBeenCalledWith([
-      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: 1,
-      }),
-    ]);
-    expect(inspectorCallSpy).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/src/__tests__/TestBatcherPublic.ts

@@ -1,96 +0,0 @@
-import { AvoBatcher } from "../AvoBatcher";
-import { AvoInspector } from "../AvoInspector";
-import { AvoNetworkCallsHandler } from "../AvoNetworkCallsHandler";
-
-import { defaultOptions } from "./constants";
-
-const inspectorVersion = process.env.npm_package_version || "";
-
-jest.mock("../AvoBatcher");
-
-describe("Batcher", () => {
-  let inspector: AvoInspector;
-
-  const { apiKey, env, version } = defaultOptions;
-  let networkHandler = new AvoNetworkCallsHandler(
-    apiKey,
-    env,
-    "my-test-app",
-    version,
-    inspectorVersion
-  );
-
-  beforeAll(() => {
-    inspector = new AvoInspector(defaultOptions);
-    inspector.enableLogging(false);
-
-    jest
-      .spyOn(AvoBatcher.prototype as any, "handleTrackSchema")
-      .mockImplementation(() => {
-        return Promise.resolve();
-      });
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-    // @ts-ignore
-    inspector.avoDeduplicator._clearEvents();
-  });
-
-  test("Batcher is initialized on Inspector init", () => {
-    expect(AvoBatcher).toHaveBeenCalledTimes(1);
-    expect(AvoBatcher).toHaveBeenCalledWith(networkHandler);
-  });
-
-  test("handleTrackSchema is called on trackSchemaFromEvent", () => {
-    const eventName = "event name";
-    const properties = {
-      prop0: "",
-      prop2: false,
-      prop3: 0,
-      prop4: 0.0,
-    };
-
-    const schema = inspector.extractSchema(properties);
-
-    inspector.trackSchemaFromEvent(eventName, properties);
-
-    expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-    expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(
-      eventName,
-      schema,
-      null,
-      null
-    );
-  });
-
-  test("handleTrackSchema is called on _avoFunctionTrackSchemaFromEvent", () => {
-    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
-    inspector._avoFunctionTrackSchemaFromEvent(
-      eventName,
-      properties,
-      eventId,
-      eventHash
-    );
-
-    expect(inspector.avoBatcher.handleTrackSchema).toHaveBeenCalledTimes(1);
-    expect(inspector.avoBatcher.handleTrackSchema).toBeCalledWith(
-      eventName,
-      schema,
-      eventId,
-      eventHash
-    );
-  });
-});