node-avo-inspector 1.0.1 → 1.1.0

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/AvoSchemaParser.ts

@@ -71,7 +71,8 @@ export class AvoSchemaParser {
     });
   }
 
-  private static getPropValueType(propValue: any): string {
+
+  private static getBasicPropType(propValue: any): string {
     let propType = typeof propValue;
     if (propValue == null) {
       return "null";
@@ -86,13 +87,29 @@ export class AvoSchemaParser {
     } else if (propType === "boolean") {
       return "boolean";
     } else if (propType === "object") {
-      if (isArray(propValue)) {
-        return "list";
-      } else {
-        return "object";
+      return "object"
+  }
+  else {
+  return "unknown";
+  }
+}
+
+  private static getPropValueType(propValue: any): string {
+    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 {
+      let propElementType = this.getBasicPropType(propElement);
+      return `list(${propElementType})`
       }
-    } else {
-      return "unknown";
+    }
+    else {
+      return this.getBasicPropType(propValue);
     }
   }
 }

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/src/__tests__/TestParsing.ts

@@ -60,7 +60,7 @@ describe("Schema Parsing", () => {
       },
     ]);
 
-    expect(res[7].propertyType).toBe(type.LIST);
+    expect(res[7].propertyType).toBe(type.STRINGLIST);
     expect(res[7].children).toMatchObject([
       type.STRING,
       [
@@ -88,13 +88,7 @@ describe("Schema Parsing", () => {
     const res = inspector.extractSchema(eventProperties);
 
     // Then
-    expect(res[0].propertyType).toBe(type.LIST);
-    expect(res[0].children).toMatchObject([
-      type.STRING,
-      type.BOOL,
-      type.INT,
-      type.FLOAT,
-    ]);
+    expect(res[0].propertyType).toBe(type.STRINGLIST);
   });
 
   test("Empty and falsy values are set correctly", () => {
@@ -124,7 +118,36 @@ describe("Schema Parsing", () => {
     expect(res[6].propertyType).toBe(type.OBJECT);
     expect(res[6].children).toMatchObject([]);
 
-    expect(res[7].propertyType).toBe(type.LIST);
+    expect(res[7].propertyType).toBe(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(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(type.FLOATLIST);
+  });
+
+
 });

package/src/__tests__/constants.ts

@@ -37,13 +37,18 @@ const sessionTimeMs = 5 * 60 * 1000;
 
 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)",
 };
 
 export {

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);
-    });
-});