avo-inspector 2.2.2-alpha → 2.2.2-alpha.3

package/dist-browser/eventSpec/AvoEventSpecFetchTypes.d.ts

@@ -1,109 +0,0 @@
-/**
- * This file is generated. Internal development changes should be made in the generator
- * and the file should be re-generated. External contributions are welcome to submit
- * changes directly to this file, and we'll apply them to the generator internally.
- */
-/**
- * Represents the type specification for a property.
- * Can be a primitive type or a nested object structure.
- */
-export interface PropertyTypeSpec {
-    /** The type category: "primitive" for simple types, "object" for nested structures */
-    type: "primitive" | "object";
-    /** For primitive: the type name (e.g., "string", "int"). For object: nested property specs */
-    value: string | Record<string, PropertySpec>;
-}
-/**
- * Represents the specification for a single property in an event.
- * Supports recursive nesting for object types.
- */
-export interface PropertySpec {
-    /** Unique identifier for this property */
-    id: string;
-    /** Type specification - contains type category and value */
-    t: PropertyTypeSpec;
-    /** Required flag */
-    r: boolean;
-    /** Is list (array) flag */
-    l?: boolean;
-    /** Minimum value (for numeric types) */
-    min?: number;
-    /** Maximum value (for numeric types) */
-    max?: number;
-    /** Enum values (allowed values for the property) */
-    v?: string[];
-    /** Regex pattern for string validation */
-    rx?: string;
-}
-/**
- * Represents a variant of an event with additional or modified properties.
- */
-export interface VariantSpec {
-    /** Unique identifier for this variant */
-    variantId: string;
-    /** Event ID for this variant (base event id) */
-    eventId: string;
-    /** Suffix to append to the base event name */
-    nameSuffix: string;
-    /** Name of the variant in this source (if different from canonical name) */
-    mappedName?: string;
-    /** Properties specific to this variant */
-    props: Record<string, PropertySpec>;
-}
-/**
- * Represents the complete specification for an event, including base event
- * and optional variants.
- */
-export interface EventSpec {
-    /** Unique identifier for this event */
-    id: string;
-    /** Canonical Avo name for this event */
-    name: string;
-    /** Name of the event in this source (if different from canonical name) */
-    mappedName?: string;
-    /** Properties for this event */
-    props: Record<string, PropertySpec>;
-    /** Variants of this event with additional/modified properties */
-    variants: VariantSpec[];
-}
-/**
- * Metadata returned with the event spec response.
- */
-export interface EventSpecMetadata {
-    /** Schema identifier */
-    schemaId: string;
-    /** Branch identifier */
-    branchId: string;
-    /** Latest action identifier (replaces versionId/createdAt) */
-    latestActionId: string;
-    /** Optional source identifier */
-    sourceId?: string;
-}
-/**
- * Response structure from the getEventSpec endpoint.
- * Contains an array of potential event matches (due to name mapping).
- */
-export interface EventSpecResponse {
-    /** Array of potential event matches */
-    events: EventSpec[];
-    /** Metadata about the schema and source */
-    metadata: EventSpecMetadata;
-}
-/** Cache entry for storing event specs with metadata. */
-export interface EventSpecCacheEntry {
-    /** The cached event specification response */
-    spec: EventSpecResponse;
-    /** Timestamp when this entry was cached */
-    timestamp: number;
-    /** Number of events processed since this entry was cached */
-    eventCount: number;
-}
-/** Parameters for fetching event specifications from the API. */
-export interface FetchEventSpecParams {
-    /** The API key */
-    apiKey: string;
-    /** The stream ID */
-    streamId: string;
-    /** The name of the event */
-    eventName: string;
-}

package/dist-browser/eventSpec/AvoEventSpecFetcher.d.ts

@@ -1,55 +0,0 @@
-/**
- * This file is generated. Internal development changes should be made in the generator
- * and the file should be re-generated. External contributions are welcome to submit
- * changes directly to this file, and we'll apply them to the generator internally.
- */
-import type { EventSpecResponse, FetchEventSpecParams } from "./AvoEventSpecFetchTypes";
-/**
- * EventSpecFetcher handles fetching event specifications from the Avo API.
- *
- * Endpoint: GET /streamInspectorEventShapes
- * Base URL: http://localhost:5001/avo-web-app/us-central1 (local dev)
- *           https://us-central1-avo-web-app.cloudfunctions.net (production)
- */
-export declare class AvoEventSpecFetcher {
-    /** Base URL for the event spec API */
-    private readonly baseUrl;
-    /** Network timeout in milliseconds */
-    private readonly timeout;
-    /** In-flight requests to prevent duplicate fetches */
-    private inFlightRequests;
-    /** Whether to log debug information */
-    private readonly shouldLog;
-    /** Environment name */
-    private readonly env;
-    constructor(timeout: number | undefined, shouldLog: boolean | undefined, env: string, baseUrl?: string);
-    /** Generates a unique key for tracking in-flight requests. */
-    private generateRequestKey;
-    /**
-     * Fetches an event specification from the API.
-     *
-     * Returns null if:
-     * - The network request fails
-     * - The response has an invalid status code (non-200)
-     * - The response is invalid or malformed
-     * - The request times out
-     *
-     * This method gracefully degrades - failures do not throw errors.
-     * When null is returned, validation should be skipped for that event.
-     */
-    fetch(params: FetchEventSpecParams): Promise<EventSpecResponse | null>;
-    /** Internal fetch implementation. */
-    private fetchInternal;
-    /** Builds the complete URL with query parameters. */
-    private buildUrl;
-    /**
-     * Makes an HTTP GET request using XMLHttpRequest.
-     * Returns the parsed JSON response or null on failure.
-     */
-    private makeRequest;
-    /**
-     * Basic shape check - ensures response has the minimum expected structure.
-     * Does not perform deep validation of all fields.
-     */
-    private hasExpectedShape;
-}

package/dist-browser/eventSpec/EventValidator.d.ts

@@ -1,90 +0,0 @@
-/**
- * EventValidator - Client-side validation of tracking events against the Avo Tracking Plan.
- *
- * This module handles:
- * 1. Matching: Identifying the most likely Event and Variant from specs
- * 2. Validation: Checking runtime properties against the matched spec rules
- */
-import type { EventSpecResponse, EventSpec, EventSpecMetadata, VariantSpec } from "./AvoEventSpecFetchTypes";
-/**
- * Validation issue codes for client-side validation.
- */
-export type ValidationIssueCode = "RequiredMissing" | "ValueBelowMin" | "ValueAboveMax" | "RegexMismatch" | "NotInAllowedValues" | "UnexpectedProperty" | "UnexpectedEvent" | "TypeMismatch";
-/**
- * Represents a validation issue found during event validation.
- *
- * Note: We do NOT include the received value to avoid sending user data to the backend.
- * The backend can correlate issues with encrypted values via propertyName matching
- * against eventProperties.encryptedPropertyValue in the payload.
- */
-export interface ValidationIssue {
-    /** The type of validation issue */
-    code: ValidationIssueCode;
-    /** Property ID (preferred over name) */
-    propertyId?: string;
-    /** Property name - used to correlate with encryptedPropertyValue in eventProperties */
-    propertyName?: string;
-    /** Expected value for the validation rule (from spec, not user data) */
-    expected?: string | number | boolean;
-}
-/**
- * Result of the validation process.
- */
-export interface ValidationResult {
-    /** ID of the matched event, null if no match found */
-    eventId: string | null;
-    /** ID of the matched variant, null if base event or no match */
-    variantId: string | null;
-    /** Event spec metadata from the response */
-    eventSpecMetadata: EventSpecMetadata;
-    /** List of all validation issues found */
-    validationErrors: ValidationIssue[];
-}
-/**
- * Runtime property value - can be any JSON-compatible type
- */
-export type RuntimePropertyValue = string | number | boolean | null | undefined | object | Array<any>;
-/**
- * Runtime properties map
- */
-export type RuntimeProperties = Record<string, RuntimePropertyValue>;
-/**
- * Internal match result for scoring
- */
-interface MatchCandidate {
-    event: EventSpec;
-    variant: VariantSpec | null;
-    score: number;
-}
-/**
- * Validates a runtime event against the EventSpecResponse.
- *
- * @param eventName - The event name observed at runtime
- * @param properties - The properties observed at runtime
- * @param specResponse - The EventSpecResponse from the backend
- * @returns ValidationResult with match info and any validation errors
- */
-export declare function validateEvent(eventName: string, properties: RuntimeProperties, specResponse: EventSpecResponse): ValidationResult;
-/**
- * Finds the closest matching Event and Variant for the runtime data.
- *
- * @param eventName - Runtime event name
- * @param properties - Runtime properties
- * @param events - Array of EventSpecs to match against
- * @returns The best matching event and variant, or null if no match
- */
-export declare function findClosestMatch(eventName: string, properties: RuntimeProperties, events: EventSpec[]): MatchCandidate | null;
-/**
- * Validates runtime properties against the matched event and variant specs.
- *
- * @param properties - Runtime properties
- * @param event - Matched EventSpec
- * @param variant - Matched VariantSpec (or null for base event)
- * @returns Array of validation issues found
- */
-export declare function validateProperties(properties: RuntimeProperties, event: EventSpec, variant: VariantSpec | null): ValidationIssue[];
-/**
- * Quick check if an event exists in the spec (without full validation).
- */
-export declare function eventExistsInSpec(eventName: string, specResponse: EventSpecResponse): boolean;
-export {};

package/dist-browser/eventSpec/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./AvoEventSpecFetchTypes";
-export * from "./AvoEventSpecCache";
-export * from "./AvoEventSpecFetcher";
-export * from "./EventValidator";

package/dist-browser/index.d.ts

@@ -1,2 +0,0 @@
-export { AvoInspector } from "./AvoInspector";
-export { AvoInspectorEnv, type AvoInspectorEnvType, type AvoInspectorEnvValueType } from "./AvoInspectorEnv";

package/dist-browser/utils.d.ts

@@ -1,3 +0,0 @@
-declare const isValueEmpty: (value: string | null | undefined) => boolean;
-declare function deepEquals(x: any, y: any): boolean;
-export { isValueEmpty, deepEquals };

package/dist-native/AvoBatcher.d.ts

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

package/dist-native/AvoBatcher.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoBatcher = void 0;
-var AvoInspector_1 = require("./AvoInspector");
-var AvoBatcher = /** @class */ (function () {
-    function AvoBatcher(networkCallsHandler) {
-        var _this = this;
-        this.events = [];
-        this.networkCallsHandler = networkCallsHandler;
-        this.batchFlushAttemptTimestamp = Date.now();
-        AvoInspector_1.AvoInspector.avoStorage
-            .getItemAsync(AvoBatcher.cacheKey)
-            .then(function (savedEvents) {
-            if (savedEvents !== null) {
-                var nonNullSavedEvents = savedEvents.filter(function (event) { return event !== null; });
-                _this.events = _this.events.concat(nonNullSavedEvents);
-                _this.checkIfBatchNeedsToBeSent();
-            }
-        });
-    }
-    AvoBatcher.prototype.handleSessionStarted = function () {
-        this.events.push(this.networkCallsHandler.bodyForSessionStartedCall());
-        this.saveEvents();
-        this.checkIfBatchNeedsToBeSent();
-    };
-    AvoBatcher.prototype.handleTrackSchema = function (eventName, schema, eventId, eventHash) {
-        this.events.push(this.networkCallsHandler.bodyForEventSchemaCall(eventName, schema, eventId, eventHash));
-        this.saveEvents();
-        if (AvoInspector_1.AvoInspector.shouldLog) {
-            console.log("Avo Inspector: saved event " +
-                eventName +
-                " with schema " +
-                JSON.stringify(schema));
-        }
-        this.checkIfBatchNeedsToBeSent();
-    };
-    AvoBatcher.prototype.checkIfBatchNeedsToBeSent = function () {
-        var batchSize = this.events.length;
-        var now = Date.now();
-        var timeSinceLastFlushAttempt = now - this.batchFlushAttemptTimestamp;
-        var sendBySize = batchSize % AvoInspector_1.AvoInspector.batchSize == 0;
-        var sendByTime = timeSinceLastFlushAttempt >= AvoInspector_1.AvoInspector.batchFlushSeconds * 1000;
-        var avoBatcher = this;
-        if (sendBySize || sendByTime) {
-            this.batchFlushAttemptTimestamp = now;
-            var sendingEvents_1 = avoBatcher.events;
-            avoBatcher.events = [];
-            this.networkCallsHandler.callInspectorWithBatchBody(sendingEvents_1, function (error) {
-                if (error != null) {
-                    avoBatcher.events = avoBatcher.events.concat(sendingEvents_1);
-                    if (AvoInspector_1.AvoInspector.shouldLog) {
-                        console.log("Avo Inspector: batch sending failed: " +
-                            error +
-                            ". We will attempt to send your schemas with next batch");
-                    }
-                }
-                else {
-                    if (AvoInspector_1.AvoInspector.shouldLog) {
-                        console.log("Avo Inspector: batch sent successfully.");
-                    }
-                }
-                avoBatcher.saveEvents();
-            });
-        }
-    };
-    AvoBatcher.prototype.saveEvents = function () {
-        if (this.events.length > 1000) {
-            var extraElements = this.events.length - 1000;
-            this.events.splice(0, extraElements);
-        }
-        AvoInspector_1.AvoInspector.avoStorage.setItem(AvoBatcher.cacheKey, this.events);
-    };
-    Object.defineProperty(AvoBatcher, "cacheKey", {
-        get: function () {
-            return "AvoInspectorEvents";
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return AvoBatcher;
-}());
-exports.AvoBatcher = AvoBatcher;

package/dist-native/AvoDeduplicator.d.ts

@@ -1,36 +0,0 @@
-export declare class AvoDeduplicator {
-    avoFunctionsEvents: {
-        [time: number]: string;
-    };
-    manualEvents: {
-        [time: number]: string;
-    };
-    avoFunctionsEventsParams: {
-        [eventName: string]: {
-            [propName: string]: any;
-        };
-    };
-    manualEventsParams: {
-        [eventName: string]: {
-            [propName: string]: any;
-        };
-    };
-    shouldRegisterEvent(eventName: string, params: {
-        [propName: string]: any;
-    }, fromAvoFunction: boolean): boolean;
-    private hasSameEventAs;
-    private lookForEventIn;
-    hasSeenEventParams(params: {
-        [propName: string]: any;
-    }, checkInAvoFunctions: boolean): boolean;
-    private lookForEventParamsIn;
-    shouldRegisterSchemaFromManually(eventName: string, eventSchema: Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>): boolean;
-    private hasSameShapeInAvoFunctionsAs;
-    private lookForEventSchemaIn;
-    private clearOldEvents;
-    private _clearEvents;
-}

package/dist-native/AvoDeduplicator.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoDeduplicator = void 0;
-var AvoSchemaParser_1 = require("./AvoSchemaParser");
-var utils_1 = require("./utils");
-var AvoDeduplicator = /** @class */ (function () {
-    function AvoDeduplicator() {
-        this.avoFunctionsEvents = {};
-        this.manualEvents = {};
-        this.avoFunctionsEventsParams = {};
-        this.manualEventsParams = {};
-    }
-    AvoDeduplicator.prototype.shouldRegisterEvent = function (eventName, params, fromAvoFunction) {
-        this.clearOldEvents();
-        if (fromAvoFunction) {
-            this.avoFunctionsEvents[Date.now()] = eventName;
-            this.avoFunctionsEventsParams[eventName] = params;
-        }
-        else {
-            this.manualEvents[Date.now()] = eventName;
-            this.manualEventsParams[eventName] = params;
-        }
-        var checkInAvoFunctions = !fromAvoFunction;
-        return !this.hasSameEventAs(eventName, params, checkInAvoFunctions);
-    };
-    AvoDeduplicator.prototype.hasSameEventAs = function (eventName, params, checkInAvoFunctions) {
-        var result = false;
-        if (checkInAvoFunctions) {
-            if (this.lookForEventIn(eventName, params, this.avoFunctionsEventsParams)) {
-                result = true;
-            }
-        }
-        else {
-            if (this.lookForEventIn(eventName, params, this.manualEventsParams)) {
-                result = true;
-            }
-        }
-        if (result) {
-            delete this.avoFunctionsEventsParams[eventName];
-            delete this.manualEventsParams[eventName];
-        }
-        return result;
-    };
-    AvoDeduplicator.prototype.lookForEventIn = function (eventName, params, eventsStorage) {
-        for (var otherEventName in eventsStorage) {
-            if (eventsStorage.hasOwnProperty(otherEventName)) {
-                if (otherEventName === eventName) {
-                    var otherParams = eventsStorage[eventName];
-                    if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    };
-    AvoDeduplicator.prototype.hasSeenEventParams = function (params, checkInAvoFunctions) {
-        var result = false;
-        if (checkInAvoFunctions) {
-            if (this.lookForEventParamsIn(params, this.avoFunctionsEventsParams)) {
-                result = true;
-            }
-        }
-        else {
-            if (this.lookForEventParamsIn(params, this.manualEventsParams)) {
-                result = true;
-            }
-        }
-        return result;
-    };
-    AvoDeduplicator.prototype.lookForEventParamsIn = function (params, eventsStorage) {
-        for (var otherEventName in eventsStorage) {
-            if (eventsStorage.hasOwnProperty(otherEventName)) {
-                var otherParams = eventsStorage[otherEventName];
-                if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    AvoDeduplicator.prototype.shouldRegisterSchemaFromManually = function (eventName, eventSchema) {
-        this.clearOldEvents();
-        return !this.hasSameShapeInAvoFunctionsAs(eventName, eventSchema);
-    };
-    AvoDeduplicator.prototype.hasSameShapeInAvoFunctionsAs = function (eventName, eventSchema) {
-        var result = false;
-        if (this.lookForEventSchemaIn(eventName, eventSchema, this.avoFunctionsEventsParams)) {
-            result = true;
-        }
-        if (result) {
-            delete this.avoFunctionsEventsParams[eventName];
-        }
-        return result;
-    };
-    AvoDeduplicator.prototype.lookForEventSchemaIn = function (eventName, eventSchema, eventsStorage) {
-        for (var otherEventName in eventsStorage) {
-            if (eventsStorage.hasOwnProperty(otherEventName)) {
-                if (otherEventName === eventName) {
-                    var otherSchema = AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventsStorage[eventName]);
-                    if (otherSchema && (0, utils_1.deepEquals)(eventSchema, otherSchema)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    };
-    AvoDeduplicator.prototype.clearOldEvents = function () {
-        var now = Date.now();
-        var msToConsiderOld = 300;
-        for (var time in this.avoFunctionsEvents) {
-            if (this.avoFunctionsEvents.hasOwnProperty(time)) {
-                var timestamp = Number(time) || 0;
-                if (now - timestamp > msToConsiderOld) {
-                    var eventName = this.avoFunctionsEvents[time];
-                    delete this.avoFunctionsEvents[time];
-                    delete this.avoFunctionsEventsParams[eventName];
-                }
-            }
-        }
-        for (var time in this.manualEvents) {
-            if (this.manualEvents.hasOwnProperty(time)) {
-                var timestamp = Number(time) || 0;
-                if (now - timestamp > msToConsiderOld) {
-                    var eventName = this.manualEvents[time];
-                    delete this.manualEvents[time];
-                    delete this.manualEventsParams[eventName];
-                }
-            }
-        }
-    };
-    // used in tests
-    AvoDeduplicator.prototype._clearEvents = function () {
-        this.avoFunctionsEvents = {};
-        this.manualEvents = {};
-        this.avoFunctionsEventsParams = {};
-        this.manualEventsParams = {};
-    };
-    return AvoDeduplicator;
-}());
-exports.AvoDeduplicator = AvoDeduplicator;

package/dist-native/AvoGuid.d.ts

@@ -1,3 +0,0 @@
-export default class AvoGuid {
-    static newGuid(): string;
-}

package/dist-native/AvoGuid.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var AvoGuid = /** @class */ (function () {
-    function AvoGuid() {
-    }
-    AvoGuid.newGuid = function () {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-            var r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    };
-    return AvoGuid;
-}());
-exports.default = AvoGuid;

package/dist-native/AvoInspector.d.ts

@@ -1,52 +0,0 @@
-import { AvoInspectorEnvValueType } from "./AvoInspectorEnv";
-import { AvoSessionTracker } from "./AvoSessionTracker";
-import { AvoBatcher } from "./AvoBatcher";
-import { AvoStorage } from "./AvoStorage";
-import { AvoDeduplicator } from "./AvoDeduplicator";
-export declare class AvoInspector {
-    environment: AvoInspectorEnvValueType;
-    avoBatcher: AvoBatcher;
-    avoDeduplicator: AvoDeduplicator;
-    sessionTracker: AvoSessionTracker;
-    apiKey: string;
-    version: string;
-    static avoStorage: AvoStorage;
-    private static _batchSize;
-    static get batchSize(): number;
-    static set batchSize(newSize: number);
-    private static _batchFlushSeconds;
-    static get batchFlushSeconds(): number;
-    private static _shouldLog;
-    static get shouldLog(): boolean;
-    static set shouldLog(enable: boolean);
-    constructor(options: {
-        apiKey: string;
-        env: AvoInspectorEnvValueType;
-        version: string;
-        appName?: string;
-    });
-    trackSchemaFromEvent(eventName: string, eventProperties: {
-        [propName: string]: any;
-    }): Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>;
-    private _avoFunctionTrackSchemaFromEvent;
-    trackSchema(eventName: string, eventSchema: Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>): void;
-    private trackSchemaInternal;
-    enableLogging(enable: boolean): void;
-    extractSchema(eventProperties: {
-        [propName: string]: any;
-    }, shouldLogIfEnabled?: boolean): Array<{
-        propertyName: string;
-        propertyType: string;
-        children?: any;
-    }>;
-    setBatchSize(newBatchSize: number): void;
-    setBatchFlushSeconds(newBatchFlushSeconds: number): void;
-}