@adventurelabs/scout-core 1.0.85 → 1.0.86

package/dist/helpers/cache.d.ts

@@ -4,6 +4,7 @@ export interface CacheMetadata {
     timestamp: number;
     ttl: number;
     version: string;
+    dbVersion: number;
     etag?: string;
     lastModified?: number;
 }
@@ -53,6 +54,8 @@ export declare class ScoutCache {
     }>;
     preloadCache(loadFunction: () => Promise<IHerdModule[]>, ttlMs?: number): Promise<void>;
     getDefaultTtl(): number;
+    getCurrentDbVersion(): number;
+    isCacheVersionCompatible(): Promise<boolean>;
     resetDatabase(): Promise<void>;
     checkDatabaseHealth(): Promise<DatabaseHealth>;
 }

package/dist/helpers/cache.js

@@ -1,5 +1,5 @@
 const DB_NAME = "ScoutCache";
-const DB_VERSION = 1;
+const DB_VERSION = 2; // Increment to invalidate old cache versions
 const HERD_MODULES_STORE = "herd_modules";
 const CACHE_METADATA_STORE = "cache_metadata";
 // Default TTL: 24 hours (1 day)
@@ -28,45 +28,49 @@ export class ScoutCache {
             };
             request.onsuccess = () => {
                 this.db = request.result;
-                // Validate that required object stores exist
-                if (!this.validateDatabaseSchema()) {
-                    console.error("[ScoutCache] Database schema validation failed");
-                    this.db.close();
-                    this.db = null;
-                    this.initPromise = null;
-                    reject(new Error("Database schema validation failed"));
-                    return;
-                }
                 console.log("[ScoutCache] IndexedDB initialized successfully");
+                // Add error handler for runtime database errors
+                this.db.onerror = (event) => {
+                    console.error("[ScoutCache] Database error:", event);
+                };
                 resolve();
             };
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;
                 try {
-                    // Create herd modules store
-                    if (!db.objectStoreNames.contains(HERD_MODULES_STORE)) {
-                        const herdModulesStore = db.createObjectStore(HERD_MODULES_STORE, {
-                            keyPath: "herdId",
-                        });
-                        herdModulesStore.createIndex("timestamp", "timestamp", {
-                            unique: false,
-                        });
-                        console.log("[ScoutCache] Created herd_modules object store");
+                    console.log(`[ScoutCache] Upgrading database to version ${DB_VERSION}`);
+                    // Remove all existing object stores to ensure clean slate
+                    const existingStores = Array.from(db.objectStoreNames);
+                    for (const storeName of existingStores) {
+                        console.log(`[ScoutCache] Removing existing object store: ${storeName}`);
+                        db.deleteObjectStore(storeName);
                     }
+                    // Create herd modules store (unified storage for all herd data)
+                    const herdModulesStore = db.createObjectStore(HERD_MODULES_STORE, {
+                        keyPath: "herdId",
+                    });
+                    herdModulesStore.createIndex("timestamp", "timestamp", {
+                        unique: false,
+                    });
+                    herdModulesStore.createIndex("dbVersion", "dbVersion", {
+                        unique: false,
+                    });
+                    console.log("[ScoutCache] Created herd_modules object store");
                     // Create cache metadata store
-                    if (!db.objectStoreNames.contains(CACHE_METADATA_STORE)) {
-                        const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
-                            keyPath: "key",
-                        });
-                        console.log("[ScoutCache] Created cache_metadata object store");
-                    }
-                    console.log("[ScoutCache] Database schema upgraded");
+                    const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
+                        keyPath: "key",
+                    });
+                    console.log("[ScoutCache] Created cache_metadata object store");
+                    console.log(`[ScoutCache] Database schema upgrade to version ${DB_VERSION} completed`);
                 }
                 catch (error) {
                     console.error("[ScoutCache] Error during database upgrade:", error);
                     reject(error);
                 }
             };
+            request.onblocked = () => {
+                console.warn("[ScoutCache] Database upgrade blocked - other connections may need to be closed");
+            };
         });
         return this.initPromise;
     }
@@ -87,7 +91,6 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        // Validate schema before creating transaction
         if (!this.validateDatabaseSchema()) {
             throw new Error("Database schema validation failed - required object stores not found");
         }
@@ -98,13 +101,14 @@ export class ScoutCache {
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             const timestamp = Date.now();
-            const version = "1.0.0";
-            // Store each herd module
+            const version = "2.0.0";
+            // Store each herd module (contains all nested data - devices, events, zones, etc.)
             herdModules.forEach((herdModule) => {
                 const cacheEntry = {
                     herdId: herdModule.herd.id.toString(),
                     data: herdModule,
                     timestamp,
+                    dbVersion: DB_VERSION,
                 };
                 herdModulesStore.put(cacheEntry);
             });
@@ -114,6 +118,7 @@ export class ScoutCache {
                 timestamp,
                 ttl: ttlMs,
                 version,
+                dbVersion: DB_VERSION,
                 etag,
                 lastModified: timestamp,
             };
@@ -124,7 +129,6 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        // Validate schema before creating transaction
         if (!this.validateDatabaseSchema()) {
             throw new Error("Database schema validation failed - required object stores not found");
         }
@@ -143,6 +147,17 @@ export class ScoutCache {
                     resolve({ data: null, isStale: true, age: 0, metadata: null });
                     return;
                 }
+                // Check if cache is from an incompatible DB version
+                if (!metadata.dbVersion || metadata.dbVersion !== DB_VERSION) {
+                    console.log(`[ScoutCache] Cache from incompatible DB version (${metadata.dbVersion || "unknown"} !== ${DB_VERSION}), invalidating`);
+                    this.stats.misses++;
+                    // Clear old cache asynchronously
+                    this.clearHerdModules().catch((error) => {
+                        console.warn("[ScoutCache] Failed to clear old cache:", error);
+                    });
+                    resolve({ data: null, isStale: true, age: 0, metadata: null });
+                    return;
+                }
                 const age = now - metadata.timestamp;
                 const isStale = age > metadata.ttl;
                 // Get all herd modules
@@ -150,7 +165,10 @@ export class ScoutCache {
                 getAllRequest.onsuccess = () => {
                     const cacheEntries = getAllRequest.result;
                     const herdModules = cacheEntries
-                        .filter((entry) => entry.data && entry.data.herd && entry.data.herd.slug)
+                        .filter((entry) => entry.data &&
+                        entry.data.herd &&
+                        entry.data.herd.slug &&
+                        entry.dbVersion === DB_VERSION)
                         .map((entry) => entry.data)
                         .sort((a, b) => (a.herd?.slug || "").localeCompare(b.herd?.slug || ""));
                     // Update stats
@@ -174,7 +192,6 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        // Validate schema before creating transaction
         if (!this.validateDatabaseSchema()) {
             throw new Error("Database schema validation failed - required object stores not found");
         }
@@ -192,7 +209,6 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        // Validate schema before creating transaction
         if (!this.validateDatabaseSchema()) {
             throw new Error("Database schema validation failed - required object stores not found");
         }
@@ -202,6 +218,7 @@ export class ScoutCache {
             transaction.oncomplete = () => resolve();
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             metadataStore.delete("herd_modules");
+            metadataStore.delete("providers");
         });
     }
     async getCacheStats() {
@@ -228,7 +245,6 @@ export class ScoutCache {
         const result = await this.getHerdModules();
         return result.age;
     }
-    // Method to check if we should refresh based on various conditions
     async shouldRefresh(maxAgeMs, forceRefresh) {
         if (forceRefresh) {
             return { shouldRefresh: true, reason: "Force refresh requested" };
@@ -237,6 +253,15 @@ export class ScoutCache {
         if (!result.data || result.data.length === 0) {
             return { shouldRefresh: true, reason: "No cached data" };
         }
+        // Check for DB version mismatch
+        if (!result.metadata ||
+            !result.metadata.dbVersion ||
+            result.metadata.dbVersion !== DB_VERSION) {
+            return {
+                shouldRefresh: true,
+                reason: `Cache from incompatible DB version (${result.metadata?.dbVersion || "unknown"} !== ${DB_VERSION})`,
+            };
+        }
         if (result.isStale) {
             return { shouldRefresh: true, reason: "Cache is stale" };
         }
@@ -248,7 +273,6 @@ export class ScoutCache {
         }
         return { shouldRefresh: false, reason: "Cache is valid and fresh" };
     }
-    // Method to preload cache with background refresh
     async preloadCache(loadFunction, ttlMs = DEFAULT_TTL_MS) {
         try {
             console.log("[ScoutCache] Starting background cache preload...");
@@ -262,11 +286,25 @@ export class ScoutCache {
             console.warn("[ScoutCache] Background preload failed:", error);
         }
     }
-    // Get the default TTL value
     getDefaultTtl() {
         return DEFAULT_TTL_MS;
     }
-    // Method to reset the database in case of corruption
+    getCurrentDbVersion() {
+        return DB_VERSION;
+    }
+    async isCacheVersionCompatible() {
+        try {
+            const result = await this.getHerdModules();
+            if (!result.metadata)
+                return false;
+            return (result.metadata.dbVersion !== undefined &&
+                result.metadata.dbVersion === DB_VERSION);
+        }
+        catch (error) {
+            console.warn("[ScoutCache] Version compatibility check failed:", error);
+            return false;
+        }
+    }
     async resetDatabase() {
         console.log("[ScoutCache] Resetting database...");
         // Close existing connection
@@ -292,7 +330,6 @@ export class ScoutCache {
             };
         });
     }
-    // Method to check database health
     async checkDatabaseHealth() {
         const issues = [];
         try {
@@ -304,9 +341,17 @@ export class ScoutCache {
             if (!this.validateDatabaseSchema()) {
                 issues.push("Database schema validation failed");
             }
+            // Check version compatibility
+            const isVersionCompatible = await this.isCacheVersionCompatible();
+            if (!isVersionCompatible) {
+                issues.push(`Cache version incompatible (current: ${DB_VERSION})`);
+            }
             // Try a simple read operation
             try {
-                await this.getHerdModules();
+                const result = await this.getHerdModules();
+                if (result.data === null && result.age === 0) {
+                    // This is expected for empty cache, not an error
+                }
             }
             catch (error) {
                 issues.push(`Read operation failed: ${error}`);

package/dist/hooks/useScoutRefresh.d.ts

@@ -43,4 +43,6 @@ export declare function useScoutRefresh(options?: UseScoutRefreshOptions): {
     getCacheStats: () => Promise<CacheStats>;
     checkDatabaseHealth: () => Promise<DatabaseHealth>;
     resetDatabase: () => Promise<void>;
+    isCacheVersionCompatible: () => Promise<boolean>;
+    getCurrentDbVersion: () => number;
 };

package/dist/hooks/useScoutRefresh.js

@@ -412,6 +412,20 @@ export function useScoutRefresh(options = {}) {
             throw error;
         }
     }, []);
+    // Utility function to check cache version compatibility
+    const isCacheVersionCompatible = useCallback(async () => {
+        try {
+            return await scoutCache.isCacheVersionCompatible();
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] Failed to check cache version compatibility:", error);
+            return false;
+        }
+    }, []);
+    // Utility function to get current DB version
+    const getCurrentDbVersion = useCallback(() => {
+        return scoutCache.getCurrentDbVersion();
+    }, []);
     return {
         handleRefresh,
         getTimingStats,
@@ -419,5 +433,7 @@ export function useScoutRefresh(options = {}) {
         getCacheStats,
         checkDatabaseHealth,
         resetDatabase,
+        isCacheVersionCompatible,
+        getCurrentDbVersion,
     };
 }

package/dist/types/db.d.ts

@@ -22,6 +22,7 @@ export type IHerd = Database["public"]["Tables"]["herds"]["Row"];
 export type ISession = Database["public"]["Tables"]["sessions"]["Row"];
 export type IConnectivity = Database["public"]["Tables"]["connectivity"]["Row"];
 export type IHeartbeat = Database["public"]["Tables"]["heartbeats"]["Row"];
+export type IProvider = Database["public"]["Tables"]["providers"]["Row"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
     file_path: string | null;

package/dist/types/herd_module.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IProvider, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
 import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
     NOT_LOADING = "NOT_LOADING",
@@ -21,7 +21,8 @@ export declare class HerdModule {
     labels: string[];
     plans: IPlan[];
     layers: ILayer[];
-    constructor(herd: IHerd, devices: IDevice[], events: IEventWithTags[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, events_page_index?: number, total_events?: number, total_events_with_filters?: number, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], sessions?: ISessionWithCoordinates[], layers?: ILayer[]);
+    providers: IProvider[];
+    constructor(herd: IHerd, devices: IDevice[], events: IEventWithTags[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, events_page_index?: number, total_events?: number, total_events_with_filters?: number, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], sessions?: ISessionWithCoordinates[], layers?: ILayer[], providers?: IProvider[]);
     to_serializable(): IHerdModule;
     static from_herd(herd: IHerd, client: SupabaseClient): Promise<HerdModule>;
 }
@@ -39,6 +40,7 @@ export interface IHerdModule {
     zones: IZoneWithActions[];
     sessions: ISessionWithCoordinates[];
     layers: ILayer[];
+    providers: IProvider[];
 }
 export interface IHerdModulesResponse {
     data: IHerdModule[];

package/dist/types/herd_module.js

@@ -4,6 +4,7 @@ import { server_get_total_events_by_herd } from "../helpers/events";
 import { EnumSessionsVisibility } from "./events";
 import { server_get_plans_by_herd } from "../helpers/plans";
 import { server_get_layers_by_herd } from "../helpers/layers";
+import { server_get_providers_by_herd } from "../helpers/providers";
 import { server_get_events_and_tags_for_devices_batch } from "../helpers/tags";
 import { server_get_users_with_herd_access } from "../helpers/users";
 import { EnumWebResponse } from "./requests";
@@ -18,7 +19,7 @@ export var EnumHerdModulesLoadingState;
     EnumHerdModulesLoadingState["UNSUCCESSFULLY_LOADED"] = "UNSUCCESSFULLY_LOADED";
 })(EnumHerdModulesLoadingState || (EnumHerdModulesLoadingState = {}));
 export class HerdModule {
-    constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = []) {
+    constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = [], providers = []) {
         this.user_roles = null;
         this.events_page_index = 0;
         this.total_events = 0;
@@ -26,6 +27,7 @@ export class HerdModule {
         this.labels = [];
         this.plans = [];
         this.layers = [];
+        this.providers = [];
         this.herd = herd;
         this.devices = devices;
         this.events = events;
@@ -39,6 +41,7 @@ export class HerdModule {
         this.zones = zones;
         this.sessions = sessions;
         this.layers = layers;
+        this.providers = providers;
     }
     to_serializable() {
         return {
@@ -55,6 +58,7 @@ export class HerdModule {
             zones: this.zones,
             sessions: this.sessions,
             layers: this.layers,
+            providers: this.providers,
         };
     }
     static async from_herd(herd, client) {
@@ -95,7 +99,7 @@ export class HerdModule {
                 }
             }
             // Run all remaining requests in parallel with individual error handling
-            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers,] = await Promise.allSettled([
+            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers, res_providers,] = await Promise.allSettled([
                 server_get_more_zones_and_actions_for_herd(herd.id, 0, 10).catch((error) => {
                     console.warn(`[HerdModule] Failed to get zones and actions:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
@@ -114,12 +118,20 @@ export class HerdModule {
                 }),
                 server_get_sessions_by_herd_id(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get sessions:`, error);
-                    return { status: EnumWebResponse.ERROR, data: [], msg: error.message };
+                    return {
+                        status: EnumWebResponse.ERROR,
+                        data: [],
+                        msg: error.message,
+                    };
                 }),
                 server_get_layers_by_herd(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get layers:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
+                server_get_providers_by_herd(herd.id).catch((error) => {
+                    console.warn(`[HerdModule] Failed to get providers:`, error);
+                    return { status: EnumWebResponse.ERROR, data: null };
+                }),
             ]);
             // Assign recent events to devices from batch results
             for (let i = 0; i < new_devices.length; i++) {
@@ -148,23 +160,28 @@ export class HerdModule {
             const plans = res_plans.status === "fulfilled" && res_plans.value?.data
                 ? res_plans.value.data
                 : [];
-            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data ? res_sessions.value.data : [];
+            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data
+                ? res_sessions.value.data
+                : [];
             const layers = res_layers.status === "fulfilled" && res_layers.value?.data
                 ? res_layers.value.data
                 : [];
+            const providers = res_providers.status === "fulfilled" && res_providers.value?.data
+                ? res_providers.value.data
+                : [];
             // TODO: store in DB and retrieve on load?
             const newLabels = LABELS;
             const endTime = Date.now();
             const loadTime = endTime - startTime;
             console.log(`[HerdModule] Loaded herd ${herd.slug} in ${loadTime}ms (${new_devices.length} devices)`);
-            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers);
+            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers, providers);
         }
         catch (error) {
             const endTime = Date.now();
             const loadTime = endTime - startTime;
             console.error(`[HerdModule] Critical error in HerdModule.from_herd (${loadTime}ms):`, error);
             // Return a minimal but valid HerdModule instance to prevent complete failure
-            return new HerdModule(herd, [], [], Date.now(), null, 0, 0, 0, [], [], [], [], []);
+            return new HerdModule(herd, [], [], Date.now(), null, 0, 0, 0, [], [], [], [], [], []);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.0.85",
+  "version": "1.0.86",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",