@adventurelabs/scout-core 1.0.83 → 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>;
@@ -47,8 +52,8 @@ export declare class ScoutCache {
         reason: string;
     }>;
     preloadCache(loadFunction: () => Promise<IHerdModule[]>, ttlMs?: number): Promise<void>;
-    getProvidersForHerd(herdId: string): Promise<CacheResult<any[]>>;
-    setProvidersForHerd(herdId: string, providers: any[], ttlMs?: number): Promise<void>;
     getDefaultTtl(): number;
+    resetDatabase(): Promise<void>;
+    checkDatabaseHealth(): Promise<DatabaseHealth>;
 }
 export declare const scoutCache: ScoutCache;

package/dist/helpers/cache.js

@@ -2,7 +2,6 @@ const DB_NAME = "ScoutCache";
 const DB_VERSION = 1;
 const HERD_MODULES_STORE = "herd_modules";
 const CACHE_METADATA_STORE = "cache_metadata";
-const PROVIDERS_STORE = "providers";
 // Default TTL: 24 hours (1 day)
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 export class ScoutCache {
@@ -23,58 +22,84 @@ 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,
-                    });
-                }
-                // Create cache metadata store
-                if (!db.objectStoreNames.contains(CACHE_METADATA_STORE)) {
-                    const metadataStore = db.createObjectStore(CACHE_METADATA_STORE, {
-                        keyPath: "key",
-                    });
+                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 providers store
-                if (!db.objectStoreNames.contains(PROVIDERS_STORE)) {
-                    const providersStore = db.createObjectStore(PROVIDERS_STORE, {
-                        keyPath: "herdId",
-                    });
-                    providersStore.createIndex("timestamp", "timestamp", {
-                        unique: false,
-                    });
+                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");
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE, PROVIDERS_STORE], "readwrite");
+        // 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);
             transaction.oncomplete = () => resolve();
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            const providersStore = transaction.objectStore(PROVIDERS_STORE);
             const timestamp = Date.now();
             const version = "1.0.0";
-            // Store each herd module and its providers
+            // Store each herd module
             herdModules.forEach((herdModule) => {
                 const cacheEntry = {
                     herdId: herdModule.herd.id.toString(),
@@ -82,15 +107,6 @@ export class ScoutCache {
                     timestamp,
                 };
                 herdModulesStore.put(cacheEntry);
-                // Store providers separately for easier querying
-                if (herdModule.providers && herdModule.providers.length > 0) {
-                    const providersCacheEntry = {
-                        herdId: herdModule.herd.id.toString(),
-                        data: herdModule.providers,
-                        timestamp,
-                    };
-                    providersStore.put(providersCacheEntry);
-                }
             });
             // Store cache metadata
             const metadata = {
@@ -102,22 +118,16 @@ export class ScoutCache {
                 lastModified: timestamp,
             };
             metadataStore.put(metadata);
-            // Store providers metadata
-            const providersMetadata = {
-                key: "providers",
-                timestamp,
-                ttl: ttlMs,
-                version,
-                etag,
-                lastModified: timestamp,
-            };
-            metadataStore.put(providersMetadata);
         });
     }
     async getHerdModules() {
         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);
@@ -164,30 +174,34 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE, PROVIDERS_STORE], "readwrite");
+        // 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);
             transaction.oncomplete = () => resolve();
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            const providersStore = transaction.objectStore(PROVIDERS_STORE);
             herdModulesStore.clear();
-            providersStore.clear();
             metadataStore.delete("herd_modules");
-            metadataStore.delete("providers");
         });
     }
     async invalidateHerdModules() {
         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);
             transaction.oncomplete = () => resolve();
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             metadataStore.delete("herd_modules");
-            metadataStore.delete("providers");
         });
     }
     async getCacheStats() {
@@ -248,84 +262,63 @@ export class ScoutCache {
             console.warn("[ScoutCache] Background preload failed:", error);
         }
     }
-    // Method to get providers for a specific herd from cache
-    async getProvidersForHerd(herdId) {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        const transaction = this.db.transaction([PROVIDERS_STORE, CACHE_METADATA_STORE], "readonly");
-        return new Promise((resolve, reject) => {
-            transaction.onerror = () => reject(transaction.error);
-            const providersStore = transaction.objectStore(PROVIDERS_STORE);
-            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            // Get metadata first
-            const metadataRequest = metadataStore.get("providers");
-            metadataRequest.onsuccess = () => {
-                const metadata = metadataRequest.result;
-                const now = Date.now();
-                if (!metadata) {
-                    this.stats.misses++;
-                    resolve({ data: null, isStale: true, age: 0, metadata: null });
-                    return;
-                }
-                const age = now - metadata.timestamp;
-                const isStale = age > metadata.ttl;
-                // Get providers for specific herd
-                const getRequest = providersStore.get(herdId);
-                getRequest.onsuccess = () => {
-                    const cacheEntry = getRequest.result;
-                    const providers = cacheEntry?.data || [];
-                    // Update stats
-                    if (providers.length > 0) {
-                        this.stats.hits++;
-                    }
-                    else {
-                        this.stats.misses++;
-                    }
-                    resolve({
-                        data: providers,
-                        isStale,
-                        age,
-                        metadata,
-                    });
-                };
-            };
-        });
+    // Get the default TTL value
+    getDefaultTtl() {
+        return DEFAULT_TTL_MS;
     }
-    // Method to set providers for a specific herd
-    async setProvidersForHerd(herdId, providers, ttlMs = DEFAULT_TTL_MS) {
-        await this.init();
-        if (!this.db)
-            throw new Error("Database not initialized");
-        const transaction = this.db.transaction([PROVIDERS_STORE, CACHE_METADATA_STORE], "readwrite");
+    // 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) => {
-            transaction.onerror = () => reject(transaction.error);
-            transaction.oncomplete = () => resolve();
-            const providersStore = transaction.objectStore(PROVIDERS_STORE);
-            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
-            const timestamp = Date.now();
-            const version = "1.0.0";
-            // Store providers
-            const providersCacheEntry = {
-                herdId,
-                data: providers,
-                timestamp,
+            const deleteRequest = indexedDB.deleteDatabase(DB_NAME);
+            deleteRequest.onsuccess = () => {
+                console.log("[ScoutCache] Database reset successfully");
+                resolve();
             };
-            providersStore.put(providersCacheEntry);
-            // Update providers metadata
-            const metadata = {
-                key: "providers",
-                timestamp,
-                ttl: ttlMs,
-                version,
-                lastModified: timestamp,
+            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
             };
-            metadataStore.put(metadata);
         });
     }
-    // Get the default TTL value
-    getDefaultTtl() {
-        return DEFAULT_TTL_MS;
+    // 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

package/dist/helpers/heartbeats.d.ts

@@ -0,0 +1,9 @@
+import { IWebResponseCompatible } from "../types/requests";
+import { IHeartbeat } from "../types/db";
+export declare function server_get_last_heartbeat_by_device(device_id: number): Promise<IWebResponseCompatible<IHeartbeat | null>>;
+export declare function server_get_heartbeats_by_device(device_id: number, limit?: number): Promise<IWebResponseCompatible<IHeartbeat[]>>;
+export declare function server_check_device_online_status(device_id: number, offline_threshold_minutes?: number): Promise<IWebResponseCompatible<{
+    is_online: boolean;
+    last_heartbeat: IHeartbeat | null;
+    minutes_since_last_heartbeat: number | null;
+}>>;

package/dist/helpers/heartbeats.js

@@ -0,0 +1,90 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+// Function to get the last heartbeat for a device
+export async function server_get_last_heartbeat_by_device(device_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        // If no heartbeats found, return null data instead of error
+        if (error.code === "PGRST116") {
+            return {
+                status: EnumWebResponse.SUCCESS,
+                msg: null,
+                data: null,
+            };
+        }
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+// Function to get all heartbeats for a device
+export async function server_get_heartbeats_by_device(device_id, limit) {
+    const supabase = await newServerClient();
+    let query = supabase
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false });
+    if (limit) {
+        query = query.limit(limit);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    else {
+        return IWebResponse.success(data || []).to_compatible();
+    }
+}
+// Function to check if a device is online based on heartbeat recency
+export async function server_check_device_online_status(device_id, offline_threshold_minutes = 5) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("heartbeats")
+        .select("*")
+        .eq("device_id", device_id)
+        .order("timestamp", { ascending: false })
+        .limit(1)
+        .single();
+    if (error) {
+        // If no heartbeats found
+        if (error.code === "PGRST116") {
+            return IWebResponse.success({
+                is_online: false,
+                last_heartbeat: null,
+                minutes_since_last_heartbeat: null,
+            }).to_compatible();
+        }
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    const now = new Date();
+    const heartbeatTime = new Date(data.timestamp);
+    const minutesSinceLastHeartbeat = Math.floor((now.getTime() - heartbeatTime.getTime()) / (1000 * 60));
+    const isOnline = minutesSinceLastHeartbeat <= offline_threshold_minutes;
+    return IWebResponse.success({
+        is_online: isOnline,
+        last_heartbeat: data,
+        minutes_since_last_heartbeat: minutesSinceLastHeartbeat,
+    }).to_compatible();
+}

package/dist/helpers/index.d.ts

@@ -6,6 +6,7 @@ export * from "./devices";
 export * from "./email";
 export * from "./events";
 export * from "./gps";
+export * from "./heartbeats";
 export * from "./herds";
 export * from "./location";
 export * from "./plans";

package/dist/helpers/index.js

@@ -6,6 +6,7 @@ export * from "./devices";
 export * from "./email";
 export * from "./events";
 export * from "./gps";
+export * from "./heartbeats";
 export * from "./herds";
 export * from "./location";
 export * from "./plans";

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/dist/providers/ScoutRefreshProvider.d.ts

@@ -289,6 +289,33 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 referencedColumns: ["id"];
             }];
         };
+        heartbeats: {
+            Row: {
+                created_at: string;
+                device_id: number;
+                id: number;
+                timestamp: string;
+            };
+            Insert: {
+                created_at?: string;
+                device_id: number;
+                id?: number;
+                timestamp: string;
+            };
+            Update: {
+                created_at?: string;
+                device_id?: number;
+                id?: number;
+                timestamp?: string;
+            };
+            Relationships: [{
+                foreignKeyName: "heartbeats_device_id_fkey";
+                columns: ["device_id"];
+                isOneToOne: false;
+                referencedRelation: "devices";
+                referencedColumns: ["id"];
+            }];
+        };
         herds: {
             Row: {
                 created_by: string;

package/dist/types/db.d.ts

@@ -21,7 +21,7 @@ export type IUserRolePerHerd = Database["public"]["Tables"]["users_roles_per_her
 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 IProvider = Database["public"]["Tables"]["providers"]["Row"];
+export type IHeartbeat = Database["public"]["Tables"]["heartbeats"]["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, IProvider, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
 import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
     NOT_LOADING = "NOT_LOADING",
@@ -21,8 +21,7 @@ export declare class HerdModule {
     labels: string[];
     plans: IPlan[];
     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[]);
+    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[]);
     to_serializable(): IHerdModule;
     static from_herd(herd: IHerd, client: SupabaseClient): Promise<HerdModule>;
 }
@@ -40,7 +39,6 @@ export interface IHerdModule {
     zones: IZoneWithActions[];
     sessions: ISessionWithCoordinates[];
     layers: ILayer[];
-    providers: IProvider[];
 }
 export interface IHerdModulesResponse {
     data: IHerdModule[];

package/dist/types/herd_module.js

@@ -4,7 +4,6 @@ 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";
@@ -19,7 +18,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 = [], providers = []) {
+    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 = []) {
         this.user_roles = null;
         this.events_page_index = 0;
         this.total_events = 0;
@@ -27,7 +26,6 @@ export class HerdModule {
         this.labels = [];
         this.plans = [];
         this.layers = [];
-        this.providers = [];
         this.herd = herd;
         this.devices = devices;
         this.events = events;
@@ -41,7 +39,6 @@ export class HerdModule {
         this.zones = zones;
         this.sessions = sessions;
         this.layers = layers;
-        this.providers = providers;
     }
     to_serializable() {
         return {
@@ -58,7 +55,6 @@ export class HerdModule {
             zones: this.zones,
             sessions: this.sessions,
             layers: this.layers,
-            providers: this.providers,
         };
     }
     static async from_herd(herd, client) {
@@ -99,7 +95,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, res_providers,] = await Promise.allSettled([
+            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers,] = 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 };
@@ -118,20 +114,12 @@ 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++) {
@@ -160,28 +148,23 @@ 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, providers);
+            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers);
         }
         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/dist/types/supabase.d.ts

@@ -302,6 +302,35 @@ export type Database = {
                     }
                 ];
             };
+            heartbeats: {
+                Row: {
+                    created_at: string;
+                    device_id: number;
+                    id: number;
+                    timestamp: string;
+                };
+                Insert: {
+                    created_at?: string;
+                    device_id: number;
+                    id?: number;
+                    timestamp: string;
+                };
+                Update: {
+                    created_at?: string;
+                    device_id?: number;
+                    id?: number;
+                    timestamp?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "heartbeats_device_id_fkey";
+                        columns: ["device_id"];
+                        isOneToOne: false;
+                        referencedRelation: "devices";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             herds: {
                 Row: {
                     created_by: string;

package/package.json

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