@adventurelabs/scout-core 1.0.84 → 1.0.85

package/dist/helpers/cache.d.ts

@@ -30,11 +30,16 @@ export interface TimingStats {
     dataProcessing: number;
     localStorage: number;
 }
+export interface DatabaseHealth {
+    healthy: boolean;
+    issues: string[];
+}
 export declare class ScoutCache {
     private db;
     private initPromise;
     private stats;
     private init;
+    private validateDatabaseSchema;
     setHerdModules(herdModules: IHerdModule[], ttlMs?: number, etag?: string): Promise<void>;
     getHerdModules(): Promise<CacheResult<IHerdModule[]>>;
     clearHerdModules(): Promise<void>;
@@ -48,5 +53,7 @@ export declare class ScoutCache {
     }>;
     preloadCache(loadFunction: () => Promise<IHerdModule[]>, ttlMs?: number): Promise<void>;
     getDefaultTtl(): number;
+    resetDatabase(): Promise<void>;
+    checkDatabaseHealth(): Promise<DatabaseHealth>;
 }
 export declare const scoutCache: ScoutCache;

package/dist/helpers/cache.js

@@ -22,39 +22,75 @@ export class ScoutCache {
             const request = indexedDB.open(DB_NAME, DB_VERSION);
             request.onerror = () => {
                 console.error("[ScoutCache] Failed to open IndexedDB:", request.error);
+                this.db = null;
+                this.initPromise = null;
                 reject(request.error);
             };
             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");
                 resolve();
             };
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;
-                // 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,
-                    });
+                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");
+                    }
+                    // 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");
                 }
-                // Create cache metadata store
-                if (!db.objectStoreNames.contains(CACHE_METADATA_STORE)) {
-                    const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
-                        keyPath: "key",
-                    });
+                catch (error) {
+                    console.error("[ScoutCache] Error during database upgrade:", error);
+                    reject(error);
                 }
-                console.log("[ScoutCache] Database schema upgraded");
             };
         });
         return this.initPromise;
     }
+    validateDatabaseSchema() {
+        if (!this.db)
+            return false;
+        const hasHerdModulesStore = this.db.objectStoreNames.contains(HERD_MODULES_STORE);
+        const hasMetadataStore = this.db.objectStoreNames.contains(CACHE_METADATA_STORE);
+        if (!hasHerdModulesStore) {
+            console.error("[ScoutCache] Missing herd_modules object store");
+        }
+        if (!hasMetadataStore) {
+            console.error("[ScoutCache] Missing cache_metadata object store");
+        }
+        return hasHerdModulesStore && hasMetadataStore;
+    }
     async setHerdModules(herdModules, ttlMs = DEFAULT_TTL_MS, etag) {
         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");
+        }
         const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -88,6 +124,10 @@ 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");
+        }
         const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readonly");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -134,6 +174,10 @@ 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");
+        }
         const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -148,6 +192,10 @@ 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");
+        }
         const transaction = this.db.transaction([CACHE_METADATA_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
@@ -218,6 +266,60 @@ export class ScoutCache {
     getDefaultTtl() {
         return DEFAULT_TTL_MS;
     }
+    // Method to reset the database in case of corruption
+    async resetDatabase() {
+        console.log("[ScoutCache] Resetting database...");
+        // Close existing connection
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+        this.initPromise = null;
+        // Delete the database
+        return new Promise((resolve, reject) => {
+            const deleteRequest = indexedDB.deleteDatabase(DB_NAME);
+            deleteRequest.onsuccess = () => {
+                console.log("[ScoutCache] Database reset successfully");
+                resolve();
+            };
+            deleteRequest.onerror = () => {
+                console.error("[ScoutCache] Failed to reset database:", deleteRequest.error);
+                reject(deleteRequest.error);
+            };
+            deleteRequest.onblocked = () => {
+                console.warn("[ScoutCache] Database reset blocked - close all other tabs");
+                // Continue anyway, it will resolve when unblocked
+            };
+        });
+    }
+    // Method to check database health
+    async checkDatabaseHealth() {
+        const issues = [];
+        try {
+            await this.init();
+            if (!this.db) {
+                issues.push("Database connection not established");
+                return { healthy: false, issues };
+            }
+            if (!this.validateDatabaseSchema()) {
+                issues.push("Database schema validation failed");
+            }
+            // Try a simple read operation
+            try {
+                await this.getHerdModules();
+            }
+            catch (error) {
+                issues.push(`Read operation failed: ${error}`);
+            }
+        }
+        catch (error) {
+            issues.push(`Database initialization failed: ${error}`);
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+        };
+    }
 }
 // Singleton instance
 export const scoutCache = new ScoutCache();

package/dist/hooks/useScoutRefresh.d.ts

@@ -1,4 +1,4 @@
-import { CacheStats, TimingStats } from "../helpers/cache";
+import { CacheStats, TimingStats, DatabaseHealth } from "../helpers/cache";
 export interface UseScoutRefreshOptions {
     autoRefresh?: boolean;
     onRefreshComplete?: () => void;
@@ -41,4 +41,6 @@ export declare function useScoutRefresh(options?: UseScoutRefreshOptions): {
     getTimingStats: () => TimingStats;
     clearCache: () => Promise<void>;
     getCacheStats: () => Promise<CacheStats>;
+    checkDatabaseHealth: () => Promise<DatabaseHealth>;
+    resetDatabase: () => Promise<void>;
 };

package/dist/hooks/useScoutRefresh.js

@@ -4,7 +4,7 @@ import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setHe
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
 import { server_get_user } from "../helpers/users";
-import { scoutCache } from "../helpers/cache";
+import { scoutCache, } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
 /**
  * Hook for refreshing scout data with detailed timing measurements and cache-first loading
@@ -107,7 +107,7 @@ export function useScoutRefresh(options = {}) {
                                     const backgroundStartTime = Date.now();
                                     const [backgroundHerdModulesResult, backgroundUserResult] = await Promise.all([
                                         server_load_herd_modules(),
-                                        server_get_user()
+                                        server_get_user(),
                                     ]);
                                     const backgroundDuration = Date.now() - backgroundStartTime;
                                     console.log(`[useScoutRefresh] Background fetch completed in ${backgroundDuration}ms`);
@@ -123,6 +123,21 @@ export function useScoutRefresh(options = {}) {
                                         }
                                         catch (cacheError) {
                                             console.warn("[useScoutRefresh] Background cache save failed:", cacheError);
+                                            // If it's an IndexedDB object store error, try to reset the database
+                                            if (cacheError instanceof Error &&
+                                                (cacheError.message.includes("object store") ||
+                                                    cacheError.message.includes("NotFoundError"))) {
+                                                console.log("[useScoutRefresh] Attempting database reset due to schema error...");
+                                                try {
+                                                    await scoutCache.resetDatabase();
+                                                    console.log("[useScoutRefresh] Database reset successful, retrying cache save...");
+                                                    await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
+                                                    console.log("[useScoutRefresh] Cache save successful after database reset");
+                                                }
+                                                catch (resetError) {
+                                                    console.error("[useScoutRefresh] Database reset and retry failed:", resetError);
+                                                }
+                                            }
                                         }
                                         // Update store with fresh data
                                         dispatch(setHerdModules(backgroundHerdModulesResult.data));
@@ -157,6 +172,19 @@ export function useScoutRefresh(options = {}) {
                 }
                 catch (cacheError) {
                     console.warn("[useScoutRefresh] Cache load failed:", cacheError);
+                    // If it's an IndexedDB object store error, try to reset the database
+                    if (cacheError instanceof Error &&
+                        (cacheError.message.includes("object store") ||
+                            cacheError.message.includes("NotFoundError"))) {
+                        console.log("[useScoutRefresh] Attempting database reset due to cache load error...");
+                        try {
+                            await scoutCache.resetDatabase();
+                            console.log("[useScoutRefresh] Database reset successful");
+                        }
+                        catch (resetError) {
+                            console.error("[useScoutRefresh] Database reset failed:", resetError);
+                        }
+                    }
                     // Continue with API call
                 }
             }
@@ -223,6 +251,21 @@ export function useScoutRefresh(options = {}) {
             }
             catch (cacheError) {
                 console.warn("[useScoutRefresh] Cache save failed:", cacheError);
+                // If it's an IndexedDB object store error, try to reset the database
+                if (cacheError instanceof Error &&
+                    (cacheError.message.includes("object store") ||
+                        cacheError.message.includes("NotFoundError"))) {
+                    console.log("[useScoutRefresh] Attempting database reset due to cache save error...");
+                    try {
+                        await scoutCache.resetDatabase();
+                        console.log("[useScoutRefresh] Database reset successful, retrying cache save...");
+                        await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                        console.log("[useScoutRefresh] Cache save successful after database reset");
+                    }
+                    catch (resetError) {
+                        console.error("[useScoutRefresh] Database reset and retry failed:", resetError);
+                    }
+                }
             }
             // Step 4: Update store with fresh data
             const dataProcessingStartTime = Date.now();
@@ -345,10 +388,36 @@ export function useScoutRefresh(options = {}) {
             };
         }
     }, []);
+    // Utility function to check database health
+    const checkDatabaseHealth = useCallback(async () => {
+        try {
+            return await scoutCache.checkDatabaseHealth();
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] Failed to check database health:", error);
+            return {
+                healthy: false,
+                issues: [`Health check failed: ${error}`],
+            };
+        }
+    }, []);
+    // Utility function to reset database
+    const resetDatabase = useCallback(async () => {
+        try {
+            await scoutCache.resetDatabase();
+            console.log("[useScoutRefresh] Database reset successfully");
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] Failed to reset database:", error);
+            throw error;
+        }
+    }, []);
     return {
         handleRefresh,
         getTimingStats,
         clearCache,
         getCacheStats,
+        checkDatabaseHealth,
+        resetDatabase,
     };
 }

package/dist/index.d.ts

@@ -30,6 +30,7 @@ export * from "./helpers/web";
 export * from "./helpers/zones";
 export * from "./helpers/storage";
 export * from "./helpers/eventUtils";
+export * from "./helpers/cache";
 export * from "./hooks/useScoutDbListener";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";

package/dist/index.js

@@ -33,6 +33,7 @@ export * from "./helpers/web";
 export * from "./helpers/zones";
 export * from "./helpers/storage";
 export * from "./helpers/eventUtils";
+export * from "./helpers/cache";
 // Hooks
 export * from "./hooks/useScoutDbListener";
 export * from "./hooks/useScoutRefresh";

package/package.json

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