avo-inspector 2.2.0 → 2.2.2-alpha

package/dist-native/AvoInspectorEnv.d.ts

@@ -0,0 +1,7 @@
+export declare const AvoInspectorEnv: {
+    readonly Prod: "prod";
+    readonly Dev: "dev";
+    readonly Staging: "staging";
+};
+export type AvoInspectorEnvType = typeof AvoInspectorEnv;
+export type AvoInspectorEnvValueType = AvoInspectorEnvType[keyof AvoInspectorEnvType];

package/dist-native/AvoInspectorEnv.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInspectorEnv = void 0;
+exports.AvoInspectorEnv = {
+    Prod: "prod",
+    Dev: "dev",
+    Staging: "staging",
+};

package/dist-native/AvoInstallationId.d.ts

@@ -0,0 +1,5 @@
+export declare class AvoInstallationId {
+    static installationId: null | string;
+    static getInstallationId(): string;
+    static get cacheKey(): string;
+}

package/dist-native/AvoInstallationId.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInstallationId = void 0;
+var AvoGuid_1 = require("./AvoGuid");
+var AvoInspector_1 = require("./AvoInspector");
+var AvoInstallationId = /** @class */ (function () {
+    function AvoInstallationId() {
+    }
+    AvoInstallationId.getInstallationId = function () {
+        if (AvoInstallationId.installationId !== null) {
+            return AvoInstallationId.installationId;
+        }
+        if (!AvoInspector_1.AvoInspector.avoStorage.isInitialized()) {
+            return "unknown";
+        }
+        var maybeInstallationId = AvoInspector_1.AvoInspector.avoStorage.getItem(AvoInstallationId.cacheKey);
+        if (maybeInstallationId === null || maybeInstallationId === undefined) {
+            AvoInstallationId.installationId = AvoGuid_1.default.newGuid();
+            AvoInspector_1.AvoInspector.avoStorage.setItem(AvoInstallationId.cacheKey, AvoInstallationId.installationId);
+        }
+        else {
+            AvoInstallationId.installationId = maybeInstallationId;
+        }
+        return AvoInstallationId.installationId;
+    };
+    Object.defineProperty(AvoInstallationId, "cacheKey", {
+        get: function () {
+            return "AvoInstallationId";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AvoInstallationId.installationId = null;
+    return AvoInstallationId;
+}());
+exports.AvoInstallationId = AvoInstallationId;

package/dist-native/AvoNetworkCallsHandler.d.ts

@@ -0,0 +1,48 @@
+export interface BaseBody {
+    apiKey: string;
+    appName: string;
+    appVersion: string;
+    libVersion: string;
+    env: string;
+    libPlatform: "web";
+    messageId: string;
+    trackingId: string;
+    createdAt: string;
+    sessionId: string;
+    samplingRate: number;
+}
+export interface SessionStartedBody extends BaseBody {
+    type: "sessionStarted";
+}
+export interface EventSchemaBody extends BaseBody {
+    type: "event";
+    eventName: string;
+    eventProperties: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    avoFunction: boolean;
+    eventId: string | null;
+    eventHash: string | null;
+}
+export declare class AvoNetworkCallsHandler {
+    private apiKey;
+    private envName;
+    private appName;
+    private appVersion;
+    private libVersion;
+    private samplingRate;
+    private sending;
+    private static trackingEndpoint;
+    constructor(apiKey: string, envName: string, appName: string, appVersion: string, libVersion: string);
+    callInspectorWithBatchBody(inEvents: Array<SessionStartedBody | EventSchemaBody>, onCompleted: (error: string | null) => any): void;
+    private fixSessionAndTrackingIds;
+    bodyForSessionStartedCall(): SessionStartedBody;
+    bodyForEventSchemaCall(eventName: string, eventProperties: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>, eventId: string | null, eventHash: string | null): EventSchemaBody;
+    private createBaseCallBody;
+}

package/dist-native/AvoNetworkCallsHandler.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoNetworkCallsHandler = void 0;
+var AvoGuid_1 = require("./AvoGuid");
+var AvoSessionTracker_1 = require("./AvoSessionTracker");
+var AvoInspector_1 = require("./AvoInspector");
+var AvoInstallationId_1 = require("./AvoInstallationId");
+var AvoNetworkCallsHandler = /** @class */ (function () {
+    function AvoNetworkCallsHandler(apiKey, envName, appName, appVersion, libVersion) {
+        this.samplingRate = 1.0;
+        this.sending = false;
+        this.apiKey = apiKey;
+        this.envName = envName;
+        this.appName = appName;
+        this.appVersion = appVersion;
+        this.libVersion = libVersion;
+    }
+    AvoNetworkCallsHandler.prototype.callInspectorWithBatchBody = function (inEvents, onCompleted) {
+        var _this = this;
+        if (this.sending) {
+            onCompleted("Batch sending cancelled because another batch sending is in progress. Your events will be sent with next batch.");
+            return;
+        }
+        var events = inEvents.filter(function (x) { return x != null; });
+        this.fixSessionAndTrackingIds(events);
+        if (events.length === 0) {
+            return;
+        }
+        if (Math.random() > this.samplingRate) {
+            if (AvoInspector_1.AvoInspector.shouldLog) {
+                console.log("Avo Inspector: last event schema dropped due to sampling rate.");
+            }
+            return;
+        }
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.log("Avo Inspector: events", events);
+            events.forEach(function (event) {
+                if (event.type === "sessionStarted") {
+                    console.log("Avo Inspector: sending session started event.");
+                }
+                else if (event.type === "event") {
+                    var schemaEvent = event;
+                    console.log("Avo Inspector: sending event " + schemaEvent.eventName + " with schema " + JSON.stringify(schemaEvent.eventProperties));
+                }
+            });
+        }
+        this.sending = true;
+        var xmlhttp = new XMLHttpRequest();
+        xmlhttp.open("POST", AvoNetworkCallsHandler.trackingEndpoint, true);
+        xmlhttp.setRequestHeader("Content-Type", "text/plain");
+        xmlhttp.send(JSON.stringify(events));
+        xmlhttp.onload = function () {
+            if (xmlhttp.status != 200) {
+                onCompleted("Error ".concat(xmlhttp.status, ": ").concat(xmlhttp.statusText));
+            }
+            else {
+                var samplingRate = JSON.parse(xmlhttp.response).samplingRate;
+                if (samplingRate !== undefined) {
+                    _this.samplingRate = samplingRate;
+                }
+                onCompleted(null);
+            }
+        };
+        xmlhttp.onerror = function () {
+            onCompleted("Request failed");
+        };
+        xmlhttp.ontimeout = function () {
+            onCompleted("Request timed out");
+        };
+        this.sending = false;
+    };
+    AvoNetworkCallsHandler.prototype.fixSessionAndTrackingIds = function (events) {
+        var knownSessionId = null;
+        var knownTrackingId = null;
+        events.forEach(function (event) {
+            if (event.sessionId !== null && event.sessionId !== undefined && event.sessionId !== "unknown") {
+                knownSessionId = event.sessionId;
+            }
+            if (event.trackingId !== null && event.trackingId !== undefined && event.trackingId !== "unknown") {
+                knownTrackingId = event.trackingId;
+            }
+        });
+        events.forEach(function (event) {
+            if (event.sessionId === "unknown") {
+                if (knownSessionId != null) {
+                    event.sessionId = knownSessionId;
+                }
+                else {
+                    event.sessionId = AvoSessionTracker_1.AvoSessionTracker.sessionId;
+                }
+            }
+            if (event.trackingId === "unknown") {
+                if (knownTrackingId != null) {
+                    event.trackingId = knownTrackingId;
+                }
+                else {
+                    event.trackingId = AvoInstallationId_1.AvoInstallationId.getInstallationId();
+                }
+            }
+        });
+    };
+    AvoNetworkCallsHandler.prototype.bodyForSessionStartedCall = function () {
+        var sessionBody = this.createBaseCallBody();
+        sessionBody.type = "sessionStarted";
+        return sessionBody;
+    };
+    AvoNetworkCallsHandler.prototype.bodyForEventSchemaCall = function (eventName, eventProperties, eventId, eventHash) {
+        var eventSchemaBody = this.createBaseCallBody();
+        eventSchemaBody.type = "event";
+        eventSchemaBody.eventName = eventName;
+        eventSchemaBody.eventProperties = eventProperties;
+        if (eventId != null) {
+            eventSchemaBody.avoFunction = true;
+            eventSchemaBody.eventId = eventId;
+            eventSchemaBody.eventHash = eventHash;
+        }
+        else {
+            eventSchemaBody.avoFunction = false;
+            eventSchemaBody.eventId = null;
+            eventSchemaBody.eventHash = null;
+        }
+        return eventSchemaBody;
+    };
+    AvoNetworkCallsHandler.prototype.createBaseCallBody = function () {
+        return {
+            apiKey: this.apiKey,
+            appName: this.appName,
+            appVersion: this.appVersion,
+            libVersion: this.libVersion,
+            env: this.envName,
+            libPlatform: "web",
+            messageId: AvoGuid_1.default.newGuid(),
+            trackingId: AvoInstallationId_1.AvoInstallationId.getInstallationId(),
+            createdAt: new Date().toISOString(),
+            sessionId: AvoSessionTracker_1.AvoSessionTracker.sessionId,
+            samplingRate: this.samplingRate,
+        };
+    };
+    AvoNetworkCallsHandler.trackingEndpoint = "https://api.avo.app/inspector/v1/track";
+    return AvoNetworkCallsHandler;
+}());
+exports.AvoNetworkCallsHandler = AvoNetworkCallsHandler;

package/dist-native/AvoSchemaParser.d.ts

@@ -0,0 +1,11 @@
+export declare class AvoSchemaParser {
+    static extractSchema(eventProperties: {
+        [propName: string]: any;
+    }): Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    private static removeDuplicates;
+    private static getPropValueType;
+}

package/dist-native/AvoSchemaParser.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoSchemaParser = void 0;
+var isArray = function (obj) {
+    return Object.prototype.toString.call(obj) === "[object Array]";
+};
+var AvoSchemaParser = /** @class */ (function () {
+    function AvoSchemaParser() {
+    }
+    AvoSchemaParser.extractSchema = function (eventProperties) {
+        var _this = this;
+        if (eventProperties === null || eventProperties === undefined) {
+            return [];
+        }
+        var mapping = function (object) {
+            if (isArray(object)) {
+                var list = object.map(function (x) {
+                    return mapping(x);
+                });
+                return _this.removeDuplicates(list);
+            }
+            else if (typeof object === "object") {
+                var mappedResult = [];
+                for (var key in object) {
+                    if (object.hasOwnProperty(key)) {
+                        var val = object[key];
+                        var mappedEntry = {
+                            propertyName: key,
+                            propertyType: _this.getPropValueType(val),
+                        };
+                        if (typeof val === "object" && val != null) {
+                            mappedEntry["children"] = mapping(val);
+                        }
+                        mappedResult.push(mappedEntry);
+                    }
+                }
+                return mappedResult;
+            }
+            else {
+                return _this.getPropValueType(object);
+            }
+        };
+        var mappedEventProps = mapping(eventProperties);
+        return mappedEventProps;
+    };
+    AvoSchemaParser.removeDuplicates = function (array) {
+        // XXX TODO fix any types
+        var primitives = { boolean: {}, number: {}, string: {} };
+        var objects = [];
+        return array.filter(function (item) {
+            var type = typeof item;
+            if (type in primitives) {
+                return primitives[type].hasOwnProperty(item)
+                    ? false
+                    : (primitives[type][item] = true);
+            }
+            else {
+                return objects.indexOf(item) >= 0 ? false : objects.push(item);
+            }
+        });
+    };
+    AvoSchemaParser.getPropValueType = function (propValue) {
+        var propType = typeof propValue;
+        if (propValue == null) {
+            return "null";
+        }
+        else if (propType === "string") {
+            return "string";
+        }
+        else if (propType === "number" || propType === "bigint") {
+            if ((propValue + "").indexOf(".") >= 0) {
+                return "float";
+            }
+            else {
+                return "int";
+            }
+        }
+        else if (propType === "boolean") {
+            return "boolean";
+        }
+        else if (propType === "object") {
+            if (isArray(propValue)) {
+                return "list";
+            }
+            else {
+                return "object";
+            }
+        }
+        else {
+            return "unknown";
+        }
+    };
+    return AvoSchemaParser;
+}());
+exports.AvoSchemaParser = AvoSchemaParser;

package/dist-native/AvoSessionTracker.d.ts

@@ -0,0 +1,15 @@
+import { AvoBatcherType } from "./AvoBatcher";
+export declare class AvoSessionTracker {
+    private static _sessionId;
+    static get sessionId(): string;
+    private _lastSessionTimestamp;
+    get lastSessionTimestamp(): number;
+    private _sessionLengthMillis;
+    get sessionLengthMillis(): number;
+    private avoBatcher;
+    constructor(avoBatcher: AvoBatcherType);
+    startOrProlongSession(atTime: number): void;
+    private static updateSessionId;
+    static get lastSessionTimestampKey(): string;
+    static get idCacheKey(): string;
+}

package/dist-native/AvoSessionTracker.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoSessionTracker = void 0;
+var AvoGuid_1 = require("./AvoGuid");
+var AvoInspector_1 = require("./AvoInspector");
+var AvoSessionTracker = /** @class */ (function () {
+    function AvoSessionTracker(avoBatcher) {
+        this._lastSessionTimestamp = null;
+        this._sessionLengthMillis = 5 * 60 * 1000;
+        this.avoBatcher = avoBatcher;
+    }
+    Object.defineProperty(AvoSessionTracker, "sessionId", {
+        get: function () {
+            if (AvoSessionTracker._sessionId === null) {
+                if (!AvoInspector_1.AvoInspector.avoStorage.isInitialized()) {
+                    return "unknown";
+                }
+                var maybeSessionId = null;
+                try {
+                    maybeSessionId = AvoInspector_1.AvoInspector.avoStorage.getItem(AvoSessionTracker.idCacheKey);
+                }
+                catch (e) {
+                    console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+                }
+                if (maybeSessionId === null || maybeSessionId === undefined) {
+                    AvoSessionTracker._sessionId = this.updateSessionId();
+                }
+                else {
+                    AvoSessionTracker._sessionId = maybeSessionId;
+                }
+            }
+            return AvoSessionTracker._sessionId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoSessionTracker.prototype, "lastSessionTimestamp", {
+        get: function () {
+            if (this._lastSessionTimestamp === null ||
+                this._lastSessionTimestamp === 0) {
+                var maybeLastSessionTimestamp = AvoInspector_1.AvoInspector.avoStorage.getItem(AvoSessionTracker.lastSessionTimestampKey);
+                if (maybeLastSessionTimestamp !== null &&
+                    maybeLastSessionTimestamp !== undefined) {
+                    this._lastSessionTimestamp = maybeLastSessionTimestamp;
+                    if (isNaN(this._lastSessionTimestamp)) {
+                        this._lastSessionTimestamp = 0;
+                    }
+                }
+                else {
+                    this._lastSessionTimestamp = 0;
+                }
+            }
+            return this._lastSessionTimestamp;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoSessionTracker.prototype, "sessionLengthMillis", {
+        get: function () {
+            return this._sessionLengthMillis;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AvoSessionTracker.prototype.startOrProlongSession = function (atTime) {
+        var _this = this;
+        AvoInspector_1.AvoInspector.avoStorage.runAfterInit(function () {
+            var timeSinceLastSession = atTime - _this.lastSessionTimestamp;
+            if (timeSinceLastSession > _this._sessionLengthMillis) {
+                AvoSessionTracker.updateSessionId();
+                _this.avoBatcher.handleSessionStarted();
+            }
+            _this._lastSessionTimestamp = atTime;
+            AvoInspector_1.AvoInspector.avoStorage.setItem(AvoSessionTracker.lastSessionTimestampKey, _this._lastSessionTimestamp);
+        });
+    };
+    AvoSessionTracker.updateSessionId = function () {
+        AvoSessionTracker._sessionId = AvoGuid_1.default.newGuid();
+        try {
+            AvoInspector_1.AvoInspector.avoStorage.setItem(AvoSessionTracker.idCacheKey, AvoSessionTracker.sessionId);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+        return AvoSessionTracker._sessionId;
+    };
+    Object.defineProperty(AvoSessionTracker, "lastSessionTimestampKey", {
+        get: function () {
+            return "AvoInspectorSessionTimestamp";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoSessionTracker, "idCacheKey", {
+        get: function () {
+            return "AvoInspectorSessionId";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AvoSessionTracker._sessionId = null;
+    return AvoSessionTracker;
+}());
+exports.AvoSessionTracker = AvoSessionTracker;

package/dist-native/AvoStorage.d.ts

@@ -0,0 +1,22 @@
+declare abstract class PlatformAvoStorage {
+    abstract init(shouldLog: boolean): void;
+    abstract getItemAsync<T>(key: string): Promise<T | null>;
+    abstract getItem<T>(key: string): T | null;
+    abstract setItem<T>(key: string, value: T): void;
+    abstract removeItem(key: string): void;
+    abstract runAfterInit(func: () => void): void;
+    abstract isInitialized(): boolean;
+    parseJson<T>(maybeItem: string | null | undefined): T | null;
+}
+export declare class AvoStorage {
+    Platform: string | null;
+    storageImpl: PlatformAvoStorage;
+    constructor(shouldLog: boolean);
+    isInitialized(): boolean;
+    getItemAsync<T>(key: string): Promise<T | null>;
+    getItem<T>(key: string): T | null;
+    setItem<T>(key: string, value: T): void;
+    removeItem(key: string): void;
+    runAfterInit(func: () => void): void;
+}
+export {};