avo-inspector 3.2.0 → 3.2.3

package/dist/esm/AvoSchemaParser.js

@@ -1,128 +0,0 @@
-const isArray = (obj) => {
-    return Object.prototype.toString.call(obj) === "[object Array]";
-};
-let _encryptValueFn;
-export class AvoSchemaParser {
-    /**
-     * Returns true only if we have a valid encryption key and can send encrypted values.
-     * If no key is present, returns false and no property values will be sent.
-     */
-    static canSendEncryptedValues(publicEncryptionKey, env) {
-        const hasEncryptionKey = publicEncryptionKey != null && publicEncryptionKey !== "";
-        const isDevOrStaging = env === "dev" || env === "staging";
-        return hasEncryptionKey && isDevOrStaging;
-    }
-    /**
-     * Returns the encrypted property value if encryption is enabled, otherwise undefined.
-     * Never returns unencrypted values - only encrypted or nothing.
-     */
-    static async getEncryptedPropertyValueIfEnabled(propertyValue, canEncrypt, publicEncryptionKey) {
-        if (!canEncrypt || !publicEncryptionKey) {
-            return undefined; // No encryption key: do not send any property values
-        }
-        try {
-            if (!_encryptValueFn) {
-                const { encryptValue } = await import("./AvoEncryption");
-                _encryptValueFn = encryptValue;
-            }
-            return await _encryptValueFn(propertyValue, publicEncryptionKey); // Only send encrypted values
-        }
-        catch (error) {
-            // If encryption fails, log the error but don't fail the entire schema extraction
-            console.error("[Avo Inspector] Failed to encrypt property value:", error instanceof Error ? error.message : String(error));
-            return undefined;
-        }
-    }
-    static async extractSchema(eventProperties, publicEncryptionKey, env) {
-        if (eventProperties === null || eventProperties === undefined) {
-            return [];
-        }
-        const canSendEncryptedValues = this.canSendEncryptedValues(publicEncryptionKey, env);
-        const mapping = async (object) => {
-            if (isArray(object)) {
-                const list = await Promise.all(object.map(async (x) => {
-                    return await mapping(x);
-                }));
-                return this.removeDuplicates(list);
-            }
-            else if (typeof object === "object") {
-                const mappedResult = [];
-                for (const key in object) {
-                    if (object.hasOwnProperty(key)) {
-                        const val = object[key];
-                        const mappedEntry = {
-                            propertyName: key,
-                            propertyType: this.getPropValueType(val)
-                        };
-                        if (typeof val === "object" && val != null) {
-                            // Object/array properties: children are encrypted individually, no need to encrypt parent
-                            mappedEntry.children = (await mapping(val));
-                        }
-                        else if (val !== undefined) {
-                            // Primitive properties: encrypt the value if encryption is enabled
-                            // Skip undefined values - they can't be encrypted and shouldn't be sent
-                            const encryptedValue = await this.getEncryptedPropertyValueIfEnabled(val, canSendEncryptedValues, publicEncryptionKey);
-                            if (encryptedValue !== undefined) {
-                                mappedEntry.encryptedPropertyValue = encryptedValue;
-                            }
-                        }
-                        mappedResult.push(mappedEntry);
-                    }
-                }
-                return mappedResult;
-            }
-            else {
-                return this.getPropValueType(object);
-            }
-        };
-        // eventProperties is always an object (Record), so mapping returns EventProperty[]
-        const mappedEventProps = (await mapping(eventProperties));
-        return mappedEventProps;
-    }
-    static removeDuplicates(array) {
-        const primitives = { boolean: {}, number: {}, string: {} };
-        const objects = [];
-        return array.filter((item) => {
-            const type = typeof item;
-            if (type in primitives && typeof item === "string") {
-                return primitives[type].hasOwnProperty(item)
-                    ? false
-                    : (primitives[type][item] = true);
-            }
-            else {
-                return objects.includes(item) ? false : objects.push(item);
-            }
-        });
-    }
-    static getPropValueType(propValue) {
-        const propType = typeof propValue;
-        if (propValue == null) {
-            return "null";
-        }
-        else if (propType === "string") {
-            return "string";
-        }
-        else if (propType === "number" || propType === "bigint") {
-            if ((propValue + "").includes(".")) {
-                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";
-        }
-    }
-}

package/dist/esm/AvoStorage.js

@@ -1,176 +0,0 @@
-class PlatformAvoStorage {
-    parseJson(maybeItem) {
-        if (maybeItem !== null && maybeItem !== undefined) {
-            return JSON.parse(maybeItem);
-        }
-        else {
-            return null;
-        }
-    }
-}
-class BrowserAvoStorage extends PlatformAvoStorage {
-    constructor() {
-        super(...arguments);
-        this.useFallbackStorage = false;
-        this.fallbackStorage = {};
-        this.storageInitialized = false;
-        this.onStorageInitFuncs = [];
-        this.shouldLog = false;
-        this.suffix = "";
-    }
-    init(shouldLog, suffix) {
-        this.shouldLog = shouldLog;
-        this.suffix = suffix;
-        this.initializeStorageWeb(this.isLocalStorageAvailable());
-    }
-    initializeStorageWeb(isLocalStorageAvailable) {
-        this.storageInitialized = true;
-        if (!isLocalStorageAvailable) {
-            this.useFallbackStorage = true;
-        }
-        this.onStorageInitFuncs.forEach((func) => {
-            func();
-        });
-    }
-    isLocalStorageAvailable() {
-        const uid = new Date().toISOString();
-        try {
-            window.localStorage.setItem(uid, uid);
-            if (window.localStorage.getItem(uid) === uid) {
-                window.localStorage.removeItem(uid);
-                return true;
-            }
-            else {
-                return false;
-            }
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    isInitialized() {
-        return this.storageInitialized;
-    }
-    async getItemAsync(key) {
-        return await new Promise((resolve, _reject) => {
-            this.runAfterInit(() => {
-                if (this.useFallbackStorage) {
-                    const maybeItem = this.fallbackStorage[key + this.suffix];
-                    resolve(this.parseJson(maybeItem));
-                }
-                else {
-                    if (typeof window !== "undefined") {
-                        let maybeItem;
-                        try {
-                            maybeItem = window.localStorage.getItem(key + this.suffix);
-                        }
-                        catch (error) {
-                            if (this.shouldLog) {
-                                console.error("Avo Inspector Storage getItemAsync error:", error);
-                            }
-                            resolve(null);
-                        }
-                        resolve(this.parseJson(maybeItem));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-            });
-        });
-    }
-    getItem(key) {
-        let maybeItem;
-        if (!this.storageInitialized) {
-            maybeItem = null;
-        }
-        else if (this.useFallbackStorage) {
-            maybeItem = this.fallbackStorage[key + this.suffix];
-        }
-        else if (process.env.BROWSER) {
-            if (typeof window !== "undefined") {
-                try {
-                    maybeItem = window.localStorage.getItem(key + this.suffix);
-                }
-                catch (error) {
-                    if (this.shouldLog) {
-                        console.error("Avo Inspector Storage getItem error:", error);
-                    }
-                }
-            }
-        }
-        return this.parseJson(maybeItem);
-    }
-    setItem(key, value) {
-        this.runAfterInit(() => {
-            if (this.useFallbackStorage) {
-                this.fallbackStorage[key + this.suffix] = JSON.stringify(value);
-            }
-            else {
-                if (typeof window !== "undefined") {
-                    try {
-                        window.localStorage.setItem(key + this.suffix, JSON.stringify(value));
-                    }
-                    catch (error) {
-                        if (this.shouldLog) {
-                            console.error("Avo Inspector Storage setItem error:", error);
-                        }
-                    }
-                }
-            }
-        });
-    }
-    removeItem(key) {
-        this.runAfterInit(() => {
-            if (this.useFallbackStorage) {
-                this.fallbackStorage[key + this.suffix] = null;
-            }
-            else {
-                if (typeof window !== "undefined") {
-                    try {
-                        window.localStorage.removeItem(key + this.suffix);
-                    }
-                    catch (error) {
-                        if (this.shouldLog) {
-                            console.error("Avo Inspector Storage removeItem error:", error);
-                        }
-                    }
-                }
-            }
-        });
-    }
-    runAfterInit(func) {
-        if (this.storageInitialized) {
-            func();
-        }
-        else {
-            this.onStorageInitFuncs.push(func);
-        }
-    }
-}
-export class AvoStorage {
-    constructor(shouldLog, suffix = "") {
-        this.Platform = null;
-        this.Platform = "browser";
-        this.storageImpl = new BrowserAvoStorage();
-        this.storageImpl.init(shouldLog, suffix);
-    }
-    isInitialized() {
-        return this.storageImpl.isInitialized();
-    }
-    async getItemAsync(key) {
-        return await this.storageImpl.getItemAsync(key);
-    }
-    getItem(key) {
-        return this.storageImpl.getItem(key);
-    }
-    setItem(key, value) {
-        this.storageImpl.setItem(key, value);
-    }
-    removeItem(key) {
-        this.storageImpl.removeItem(key);
-    }
-    runAfterInit(func) {
-        this.storageImpl.runAfterInit(func);
-    }
-}

package/dist/esm/AvoStreamId.js

@@ -1,140 +0,0 @@
-import AvoGuid from "./AvoGuid";
-import { AvoInspector } from "./AvoInspector";
-/**
- * AvoStreamId manages an ephemeral stream identifier.
- *
- * The stream ID is generated and stored persistently, but resets after:
- * - 4 hours of total age AND
- * - 2 hours of idle time (no activity)
- *
- * This ensures the ID is truly anonymous by not persisting indefinitely,
- * while still maintaining session continuity during active usage.
- */
-export class AvoStreamId {
-    /**
-     * Get the stream ID. If it doesn't exist or has expired, generates a new one.
-     * Returns "unknown" if storage is not initialized.
-     */
-    static get streamId() {
-        // Return cached value if available and not expired
-        if (AvoStreamId._streamId !== null && !AvoStreamId.shouldReset()) {
-            AvoStreamId.updateLastActivity();
-            return AvoStreamId._streamId;
-        }
-        if (!AvoInspector.avoStorage.isInitialized()) {
-            return "unknown";
-        }
-        // Load from storage
-        AvoStreamId.loadFromStorage();
-        // Check if we should reset
-        if (AvoStreamId._streamId !== null && AvoStreamId.shouldReset()) {
-            return AvoStreamId.generateAndStoreNew();
-        }
-        // If no ID exists, generate new one
-        if (AvoStreamId._streamId === null) {
-            return AvoStreamId.generateAndStoreNew();
-        }
-        // Update last activity and return existing
-        AvoStreamId.updateLastActivity();
-        return AvoStreamId._streamId;
-    }
-    /**
-     * Check if the stream ID should be reset based on age and idle time.
-     */
-    static shouldReset() {
-        if (AvoStreamId._createdAt === null || AvoStreamId._lastActivityAt === null) {
-            return false;
-        }
-        const now = Date.now();
-        const age = now - AvoStreamId._createdAt;
-        const idleTime = now - AvoStreamId._lastActivityAt;
-        // Reset if older than 4 hours AND idle for 2+ hours
-        return age > AvoStreamId.MAX_AGE_MS && idleTime > AvoStreamId.IDLE_THRESHOLD_MS;
-    }
-    /**
-     * Load stream ID and timestamps from storage into cache.
-     */
-    static loadFromStorage() {
-        try {
-            const storedId = AvoInspector.avoStorage.getItem(AvoStreamId.STREAM_ID_KEY);
-            const createdAt = AvoInspector.avoStorage.getItem(AvoStreamId.CREATED_AT_KEY);
-            const lastActivityAt = AvoInspector.avoStorage.getItem(AvoStreamId.LAST_ACTIVITY_KEY);
-            if (storedId !== null && storedId !== undefined) {
-                AvoStreamId._streamId = storedId;
-                AvoStreamId._createdAt = createdAt ?? Date.now();
-                AvoStreamId._lastActivityAt = lastActivityAt ?? Date.now();
-            }
-        }
-        catch (e) {
-            console.error("Avo Inspector: Error reading stream ID from storage. Please report to support@avo.app.", e);
-        }
-    }
-    /**
-     * Generate a new stream ID and store it with timestamps.
-     */
-    static generateAndStoreNew() {
-        const now = Date.now();
-        AvoStreamId._streamId = AvoGuid.newGuid();
-        AvoStreamId._createdAt = now;
-        AvoStreamId._lastActivityAt = now;
-        try {
-            AvoInspector.avoStorage.setItem(AvoStreamId.STREAM_ID_KEY, AvoStreamId._streamId);
-            AvoInspector.avoStorage.setItem(AvoStreamId.CREATED_AT_KEY, AvoStreamId._createdAt);
-            AvoInspector.avoStorage.setItem(AvoStreamId.LAST_ACTIVITY_KEY, AvoStreamId._lastActivityAt);
-        }
-        catch (e) {
-            console.error("Avo Inspector: Error saving stream ID to storage. Please report to support@avo.app.", e);
-        }
-        return AvoStreamId._streamId;
-    }
-    /**
-     * Update the last activity timestamp.
-     */
-    static updateLastActivity() {
-        const now = Date.now();
-        AvoStreamId._lastActivityAt = now;
-        try {
-            AvoInspector.avoStorage.setItem(AvoStreamId.LAST_ACTIVITY_KEY, now);
-        }
-        catch (e) {
-            // Silently fail - not critical
-        }
-    }
-    /**
-     * The storage key used to persist the stream ID.
-     */
-    static get storageKey() {
-        return AvoStreamId.STREAM_ID_KEY;
-    }
-    /**
-     * The storage key for created at timestamp.
-     */
-    static get createdAtKey() {
-        return AvoStreamId.CREATED_AT_KEY;
-    }
-    /**
-     * The storage key for last activity timestamp.
-     */
-    static get lastActivityKey() {
-        return AvoStreamId.LAST_ACTIVITY_KEY;
-    }
-    /**
-     * Clear the cached stream ID. The next access will reload from storage.
-     * This is primarily useful for testing.
-     */
-    static clearCache() {
-        AvoStreamId._streamId = null;
-        AvoStreamId._createdAt = null;
-        AvoStreamId._lastActivityAt = null;
-    }
-}
-AvoStreamId._streamId = null;
-AvoStreamId._createdAt = null;
-AvoStreamId._lastActivityAt = null;
-// Ephemeral reset thresholds
-AvoStreamId.MAX_AGE_MS = 4 * 60 * 60 * 1000; // 4 hours
-AvoStreamId.IDLE_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
-// Storage keys
-AvoStreamId.STREAM_ID_KEY = "AvoInspectorStreamId";
-AvoStreamId.CREATED_AT_KEY = "AvoInspectorStreamIdCreatedAt";
-AvoStreamId.LAST_ACTIVITY_KEY = "AvoInspectorStreamIdLastActivityAt";

package/dist/esm/eventSpec/AvoEventSpecCache.js

@@ -1,165 +0,0 @@
-/**
- * EventSpecCache implements a dual-condition cache with LRU eviction.
- *
- * Cache Policy:
- * - Entries expire after 5 minutes OR 50 cache hits, whichever comes first
- * - When 50 cache hits occur globally, the oldest cached entry is evicted
- * - Each cache entry tracks: spec, timestamp, and hit count
- *
- * Cache Key Format: ${apiKey}:${streamId}:${eventName}
- *
- * Note: Event count only increments on cache hits, not on every tracked event.
- * This ensures the cache evicts based on actual usage, not overall tracking volume.
- */
-export class EventSpecCache {
-    constructor(shouldLog = false) {
-        /** Time-to-live in milliseconds (1 minute) */
-        this.TTL_MS = 60 * 1000;
-        /** Maximum cache hit count before rotating cache (50 hits) */
-        this.MAX_EVENT_COUNT = 50;
-        /** Global cache hit counter to track when to rotate cache */
-        this.globalEventCount = 0;
-        this.cache = new Map();
-        this.shouldLog = shouldLog;
-    }
-    /**
-     * Generates a cache key from the provided parameters.
-     */
-    generateKey(apiKey, streamId, eventName) {
-        return `${apiKey}:${streamId}:${eventName}`;
-    }
-    /**
-     * Checks if a non-expired cache entry exists for the given key.
-     * Returns true even for cached null specs (empty backend responses).
-     * Use this to distinguish between "cache miss" and "cached empty response".
-     */
-    contains(apiKey, streamId, eventName) {
-        const key = this.generateKey(apiKey, streamId, eventName);
-        const entry = this.cache.get(key);
-        if (!entry) {
-            return false;
-        }
-        if (this.shouldEvict(entry)) {
-            this.cache.delete(key);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Retrieves an event spec response from the cache if it exists and is valid.
-     * Returns null if the entry is missing, expired, has exceeded event count,
-     * or if the cached spec itself is null (empty backend response).
-     *
-     * On cache hit, increments the hit count for this entry and the global counter.
-     */
-    get(apiKey, streamId, eventName) {
-        const key = this.generateKey(apiKey, streamId, eventName);
-        const entry = this.cache.get(key);
-        if (!entry) {
-            return null;
-        }
-        // Check if entry has expired
-        if (this.shouldEvict(entry)) {
-            this.cache.delete(key);
-            return null;
-        }
-        if (this.shouldLog) {
-            console.log(`[Avo Inspector] Cache hit for key: ${key}`);
-        }
-        // Update lastAccessed for LRU (Least Recently Used) eviction
-        entry.lastAccessed = Date.now();
-        // Increment hit count for this entry
-        entry.eventCount++;
-        this.globalEventCount++;
-        // Check if we need to evict the oldest entry
-        if (this.globalEventCount >= this.MAX_EVENT_COUNT) {
-            this.evictOldest();
-            this.globalEventCount = 0;
-        }
-        return entry.spec;
-    }
-    /**
-     * Stores an event spec response in the cache.
-     * Pass null to cache an empty response (event not found on backend).
-     */
-    set(apiKey, streamId, eventName, spec) {
-        const key = this.generateKey(apiKey, streamId, eventName);
-        const now = Date.now();
-        const entry = {
-            spec,
-            timestamp: now,
-            lastAccessed: now,
-            eventCount: 0
-        };
-        this.cache.set(key, entry);
-    }
-    /**
-     * Determines if a cache entry should be evicted based on:
-     * - Age (older than 5 minutes)
-     * - Hit count (50 or more cache hits)
-     */
-    shouldEvict(entry) {
-        const age = Date.now() - entry.timestamp;
-        const ageExpired = age > this.TTL_MS;
-        const countExpired = entry.eventCount >= this.MAX_EVENT_COUNT;
-        return ageExpired || countExpired;
-    }
-    /**
-     * Evicts the least recently used cache entry based on lastAccessed timestamp.
-     * This implements the LRU (Least Recently Used) eviction policy.
-     */
-    evictOldest() {
-        if (this.cache.size === 0) {
-            return;
-        }
-        let lruKey = null;
-        let oldestAccessTime = Infinity;
-        // Find the entry with the oldest lastAccessed time (least recently used)
-        this.cache.forEach((entry, key) => {
-            if (entry.lastAccessed < oldestAccessTime) {
-                oldestAccessTime = entry.lastAccessed;
-                lruKey = key;
-            }
-        });
-        // Remove the least recently used entry
-        if (lruKey !== null) {
-            this.cache.delete(lruKey);
-        }
-    }
-    /**
-     * Clears all cached entries. Useful for testing.
-     */
-    clear() {
-        this.cache.clear();
-        this.globalEventCount = 0;
-        if (this.shouldLog) {
-            console.log("[Avo Inspector] Cache cleared");
-        }
-    }
-    /**
-     * Returns the current size of the cache.
-     */
-    size() {
-        return this.cache.size;
-    }
-    /**
-     * Returns cache statistics for debugging.
-     */
-    getStats() {
-        const entries = [];
-        const now = Date.now();
-        this.cache.forEach((entry, key) => {
-            entries.push({
-                key,
-                age: now - entry.timestamp,
-                lastAccessedAgo: now - entry.lastAccessed,
-                eventCount: entry.eventCount
-            });
-        });
-        return {
-            size: this.cache.size,
-            globalEventCount: this.globalEventCount,
-            entries
-        };
-    }
-}

package/dist/esm/eventSpec/AvoEventSpecFetchTypes.js

@@ -1,6 +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.
- */
-export {};