@adventurelabs/scout-core 1.0.39 → 1.0.41

package/dist/api_keys/actions.d.ts

@@ -1,2 +1,5 @@
 import { IApiKeyScout } from "../types/db";
 export declare function server_list_api_keys(device_id: string): Promise<IApiKeyScout[]>;
+export declare function server_list_api_keys_batch(device_ids: number[]): Promise<{
+    [device_id: number]: IApiKeyScout[];
+}>;

package/dist/api_keys/actions.js

@@ -12,9 +12,36 @@ export async function server_list_api_keys(device_id) {
         return [];
     const data_to_return = [];
     for (let i = 0; i < data.length; i++) {
-        // convert data to IApiKeyScout
         const converted_data = JSON.parse(data[i]);
         data_to_return.push(converted_data);
     }
     return data_to_return;
 }
+export async function server_list_api_keys_batch(device_ids) {
+    console.log(`[API Keys Batch] Starting batch load for ${device_ids.length} devices`);
+    const supabase = await newServerClient();
+    const { data, error } = await supabase.rpc("load_api_keys_batch", {
+        device_ids: device_ids,
+    });
+    if (error) {
+        console.error("Error listing API keys in batch:", error.message);
+        return {};
+    }
+    if (!data)
+        return {};
+    console.log(`[API Keys Batch] Received ${data.length} API key records`);
+    const result = {};
+    // Group API keys by device_id
+    data.forEach((item) => {
+        const device_id = item.device_id;
+        if (!result[device_id]) {
+            result[device_id] = [];
+        }
+        result[device_id].push({
+            id: item.api_key_id.toString(),
+            key: item.api_key_key,
+        });
+    });
+    console.log(`[API Keys Batch] Returning API keys for ${Object.keys(result).length} devices`);
+    return result;
+}

package/dist/helpers/storage.d.ts

@@ -8,12 +8,8 @@ import { Database } from "../types/supabase";
  * @returns Promise<string | null> - The signed URL or null if error
  */
 export declare function generateSignedUrl(filePath: string, expiresIn?: number, supabaseClient?: SupabaseClient<Database>): Promise<string | null>;
-/**
- * Generates signed URLs for multiple events and sets them as media_url
- * @param events - Array of events that may have file_path
- * @param supabaseClient - Optional Supabase client (will create new one if not provided)
- * @returns Promise<Array> - Events with signed URLs set as media_url
- */
+export declare function generateSignedUrlsBatch(filePaths: string[], expiresIn?: number, supabaseClient?: SupabaseClient<Database>): Promise<Map<string, string | null>>;
+export declare function addSignedUrlsToEventsBatch(events: any[], supabaseClient?: SupabaseClient<Database>): Promise<any[]>;
 export declare function addSignedUrlsToEvents(events: any[], supabaseClient?: SupabaseClient<Database>): Promise<any[]>;
 /**
  * Generates a signed URL for a single event and sets it as media_url

package/dist/helpers/storage.js

@@ -25,26 +25,59 @@ export async function generateSignedUrl(filePath, expiresIn = 3600, supabaseClie
         return null;
     }
 }
-/**
- * Generates signed URLs for multiple events and sets them as media_url
- * @param events - Array of events that may have file_path
- * @param supabaseClient - Optional Supabase client (will create new one if not provided)
- * @returns Promise<Array> - Events with signed URLs set as media_url
- */
-export async function addSignedUrlsToEvents(events, supabaseClient) {
-    const eventsWithSignedUrls = await Promise.all(events.map(async (event) => {
-        // If event has a file_path, generate a signed URL and set it as media_url
-        if (event.file_path) {
-            const signedUrl = await generateSignedUrl(event.file_path, 3600, supabaseClient);
+export async function generateSignedUrlsBatch(filePaths, expiresIn = 3600, supabaseClient) {
+    try {
+        const supabase = supabaseClient || (await newServerClient());
+        const urlMap = new Map();
+        const signedUrlPromises = filePaths.map(async (filePath) => {
+            try {
+                const { data, error } = await supabase.storage
+                    .from(BUCKET_NAME_SCOUT)
+                    .createSignedUrl(filePath, expiresIn);
+                if (error) {
+                    console.error(`Error generating signed URL for ${filePath}:`, error.message);
+                    return { filePath, signedUrl: null };
+                }
+                return { filePath, signedUrl: data.signedUrl };
+            }
+            catch (error) {
+                console.error(`Error in generateSignedUrl for ${filePath}:`, error);
+                return { filePath, signedUrl: null };
+            }
+        });
+        const results = await Promise.all(signedUrlPromises);
+        results.forEach(({ filePath, signedUrl }) => {
+            urlMap.set(filePath, signedUrl);
+        });
+        return urlMap;
+    }
+    catch (error) {
+        console.error("Error in generateSignedUrlsBatch:", error);
+        return new Map();
+    }
+}
+export async function addSignedUrlsToEventsBatch(events, supabaseClient) {
+    const filePaths = events
+        .map((event) => event.file_path)
+        .filter((path) => path)
+        .filter((path, index, array) => array.indexOf(path) === index);
+    if (filePaths.length === 0) {
+        return events;
+    }
+    const urlMap = await generateSignedUrlsBatch(filePaths, 3600, supabaseClient);
+    return events.map((event) => {
+        if (event.file_path && urlMap.has(event.file_path)) {
+            const signedUrl = urlMap.get(event.file_path);
             return {
                 ...event,
-                media_url: signedUrl || event.media_url, // Fall back to existing media_url if signed URL fails
+                media_url: signedUrl || event.media_url,
             };
         }
-        // If no file_path, keep existing media_url
         return event;
-    }));
-    return eventsWithSignedUrls;
+    });
+}
+export async function addSignedUrlsToEvents(events, supabaseClient) {
+    return addSignedUrlsToEventsBatch(events, supabaseClient);
 }
 /**
  * Generates a signed URL for a single event and sets it as media_url
@@ -61,6 +94,5 @@ export async function addSignedUrlToEvent(event, supabaseClient) {
             media_url: signedUrl || event.media_url, // Fall back to existing media_url if signed URL fails
         };
     }
-    // If no file_path, keep existing media_url
     return event;
 }

package/dist/helpers/tags.d.ts

@@ -5,4 +5,7 @@ export declare function server_delete_tags_by_ids(tag_ids: number[]): Promise<IW
 export declare function server_update_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
 export declare function server_get_more_events_with_tags_by_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IEventWithTags[]>>;
 export declare function server_get_events_and_tags_for_device(device_id: number, limit?: number): Promise<IWebResponseCompatible<IEventWithTags[]>>;
+export declare function server_get_events_and_tags_for_devices_batch(device_ids: number[], limit?: number): Promise<IWebResponseCompatible<{
+    [device_id: number]: IEventWithTags[];
+}>>;
 export declare function get_event_and_tags_by_event_id(event_id: number): Promise<IWebResponseCompatible<IEventWithTags>>;

package/dist/helpers/tags.js

@@ -146,6 +146,62 @@ export async function server_get_events_and_tags_for_device(device_id, limit = 3
     const eventsWithSignedUrls = await addSignedUrlsToEvents(data || [], supabase);
     return IWebResponse.success(eventsWithSignedUrls).to_compatible();
 }
+export async function server_get_events_and_tags_for_devices_batch(device_ids, limit = 1) {
+    console.log(`[Events Batch] Starting batch load for ${device_ids.length} devices (limit: ${limit})`);
+    const supabase = await newServerClient();
+    // Use single RPC call for all devices
+    const { data, error } = await supabase.rpc("get_events_and_tags_for_devices_batch", {
+        device_ids: device_ids,
+        limit_per_device: limit,
+    });
+    if (error) {
+        console.error("Error fetching events for devices in batch:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: {},
+        };
+    }
+    if (!data)
+        return IWebResponse.success({}).to_compatible();
+    console.log(`[Events Batch] Received ${data.length} event records`);
+    // Group events by device_id
+    const eventsByDevice = {};
+    data.forEach((row) => {
+        const device_id = row.device_id;
+        if (!eventsByDevice[device_id]) {
+            eventsByDevice[device_id] = [];
+        }
+        // Create event object from the new structure
+        const event = {
+            id: row.event_id,
+            inserted_at: row.inserted_at,
+            message: row.message,
+            media_url: row.media_url,
+            file_path: row.file_path,
+            latitude: row.latitude,
+            longitude: row.longitude,
+            altitude: row.altitude,
+            heading: row.heading,
+            media_type: row.media_type,
+            device_id: device_id,
+            timestamp_observation: row.timestamp_observation,
+            is_public: row.is_public,
+            earthranger_url: row.earthranger_url,
+            tags: Array.isArray(row.tags) ? row.tags : [],
+        };
+        eventsByDevice[device_id].push(event);
+    });
+    // Add signed URLs to all events
+    const result = {};
+    for (const device_id in eventsByDevice) {
+        const events = eventsByDevice[device_id];
+        const eventsWithSignedUrls = await addSignedUrlsToEvents(events, supabase);
+        result[parseInt(device_id)] = eventsWithSignedUrls;
+    }
+    console.log(`[Events Batch] Returning events for ${Object.keys(result).length} devices`);
+    return IWebResponse.success(result).to_compatible();
+}
 export async function get_event_and_tags_by_event_id(event_id) {
     const supabase = await newServerClient();
     // use actual sql query to get event and tags instead of rpc

package/dist/hooks/useScoutDbListener.d.ts

@@ -7,59 +7,12 @@ declare enum ConnectionState {
     ERROR = "error"
 }
 /**
- * Hook for listening to real-time database changes with robust disconnect handling.
- *
- * Features:
- * - Automatic reconnection with exponential backoff
- * - Connection state tracking
- * - Error handling and retry logic
- * - Manual reconnection capability
- *
- * @param scoutSupabase - The Supabase client instance
- * @returns Connection status and control functions
+ * Hook for listening to real-time database changes
  */
 export declare function useScoutDbListener(scoutSupabase: SupabaseClient<Database>): {
     connectionState: ConnectionState;
     lastError: string | null;
-    retryCount: number;
-    reconnect: () => void;
     isConnected: boolean;
     isConnecting: boolean;
 };
 export {};
-/**
- * Return type for useScoutDbListener hook
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const {
- *     isConnected,
- *     isConnecting,
- *     lastError,
- *     retryCount,
- *     reconnect
- *   } = useConnectionStatus();
- *
- *   if (isConnecting) {
- *     return <div>Connecting to database...</div>;
- *   }
- *
- *   if (lastError) {
- *     return (
- *       <div>
- *         <p>Connection error: {lastError}</p>
- *         <p>Retry attempts: {retryCount}</p>
- *         <button onClick={reconnect}>Reconnect</button>
- *       </div>
- *     );
- *   }
- *
- *   if (!isConnected) {
- *     return <div>Disconnected from database</div>;
- *   }
- *
- *   return <div>Connected to database</div>;
- * }
- * ```
- */

package/dist/hooks/useScoutDbListener.js

@@ -1,7 +1,7 @@
 "use client";
 import { useAppDispatch } from "../store/hooks";
-import { useEffect, useRef, useState, useCallback } from "react";
-import { addDevice, addPlan, addTag, addSessionToStore, deleteDevice, deletePlan, deleteSessionFromStore, deleteTag, updateDevice, updatePlan, updateSessionInStore, updateTag, } from "../store/scout";
+import { useEffect, useRef, useState } from "react";
+import { addDevice, addPlan, addTag, deleteDevice, deletePlan, deleteTag, updateDevice, updatePlan, updateTag, } from "../store/scout";
 // Connection state enum
 var ConnectionState;
 (function (ConnectionState) {
@@ -10,52 +10,20 @@ var ConnectionState;
     ConnectionState["CONNECTED"] = "connected";
     ConnectionState["ERROR"] = "error";
 })(ConnectionState || (ConnectionState = {}));
-// Reconnection configuration
-const RECONNECTION_CONFIG = {
-    MAX_RETRIES: 10,
-    INITIAL_DELAY: 1000, // 1 second
-    MAX_DELAY: 30000, // 30 seconds
-    BACKOFF_MULTIPLIER: 2,
-    JITTER_FACTOR: 0.1, // 10% jitter
-};
 /**
- * Hook for listening to real-time database changes with robust disconnect handling.
- *
- * Features:
- * - Automatic reconnection with exponential backoff
- * - Connection state tracking
- * - Error handling and retry logic
- * - Manual reconnection capability
- *
- * @param scoutSupabase - The Supabase client instance
- * @returns Connection status and control functions
+ * Hook for listening to real-time database changes
  */
 export function useScoutDbListener(scoutSupabase) {
-    const supabase = useRef(null);
     const channels = useRef([]);
     const dispatch = useAppDispatch();
-    // Connection state management
     const [connectionState, setConnectionState] = useState(ConnectionState.DISCONNECTED);
     const [lastError, setLastError] = useState(null);
-    const [retryCount, setRetryCount] = useState(0);
-    // Reconnection management
-    const reconnectTimeoutRef = useRef(null);
-    const isInitializingRef = useRef(false);
-    const isDestroyedRef = useRef(false);
-    // Calculate exponential backoff delay with jitter
-    const calculateBackoffDelay = useCallback((attempt) => {
-        const baseDelay = Math.min(RECONNECTION_CONFIG.INITIAL_DELAY *
-            Math.pow(RECONNECTION_CONFIG.BACKOFF_MULTIPLIER, attempt), RECONNECTION_CONFIG.MAX_DELAY);
-        const jitter = baseDelay * RECONNECTION_CONFIG.JITTER_FACTOR * (Math.random() - 0.5);
-        return Math.max(100, baseDelay + jitter); // Minimum 100ms delay
-    }, []);
     // Clean up all channels
-    const cleanupChannels = useCallback(() => {
-        console.log("[DB Listener] 🧹 Cleaning up channels");
+    const cleanupChannels = () => {
         channels.current.forEach((channel) => {
-            if (channel && supabase.current) {
+            if (channel && scoutSupabase) {
                 try {
-                    supabase.current.removeChannel(channel);
+                    scoutSupabase.removeChannel(channel);
                 }
                 catch (error) {
                     console.warn("[DB Listener] Error removing channel:", error);
@@ -63,153 +31,91 @@ export function useScoutDbListener(scoutSupabase) {
             }
         });
         channels.current = [];
-    }, []);
-    // Cancel any pending reconnection attempts
-    const cancelReconnection = useCallback(() => {
-        if (reconnectTimeoutRef.current) {
-            clearTimeout(reconnectTimeoutRef.current);
-            reconnectTimeoutRef.current = null;
-        }
-    }, []);
-    // Test database connection
-    const testDbConnection = useCallback(async () => {
-        if (!supabase.current)
-            return false;
-        try {
-            const { data, error } = await supabase.current
-                .from("tags")
-                .select("count")
-                .limit(1);
-            if (error) {
-                console.warn("[DB Listener] DB connection test failed:", error);
-                return false;
-            }
-            console.log("[DB Listener] ✅ DB connection test successful");
-            return true;
-        }
-        catch (err) {
-            console.error("[DB Listener] DB connection test failed:", err);
-            return false;
-        }
-    }, []);
-    // Set up realtime authentication
-    const setupRealtimeAuth = useCallback(async () => {
-        if (!supabase.current)
-            return false;
-        try {
-            await supabase.current.realtime.setAuth();
-            console.log("[DB Listener] ✅ Realtime authentication set up successfully");
-            return true;
-        }
-        catch (err) {
-            console.warn("[DB Listener] ❌ Failed to set up realtime authentication:", err);
-            return false;
-        }
-    }, []);
-    // Generic event handler factory
-    const createEventHandler = useCallback((action, dataKey, entityName) => {
-        return (payload) => {
-            console.log(`[DB Listener] ${entityName} ${payload.event} received:`, payload);
-            const data = payload[dataKey];
-            if (!data) {
-                console.error(`[DB Listener] ${entityName} ${payload.event} - Invalid payload, missing ${dataKey} data`);
-                return;
-            }
-            action(data);
-        };
-    }, []);
-    // Create event handlers using the factory
-    const handlers = useCallback(() => ({
+    };
+    // Create event handlers
+    const handlers = {
         tags: {
-            INSERT: createEventHandler(dispatch.bind(null, addTag), "new", "Tag"),
-            UPDATE: createEventHandler(dispatch.bind(null, updateTag), "new", "Tag"),
-            DELETE: createEventHandler(dispatch.bind(null, deleteTag), "old", "Tag"),
+            INSERT: (payload) => {
+                if (payload.new)
+                    dispatch(addTag(payload.new));
+            },
+            UPDATE: (payload) => {
+                if (payload.new)
+                    dispatch(updateTag(payload.new));
+            },
+            DELETE: (payload) => {
+                if (payload.old)
+                    dispatch(deleteTag(payload.old));
+            },
         },
         devices: {
-            INSERT: createEventHandler(dispatch.bind(null, addDevice), "new", "Device"),
-            UPDATE: createEventHandler(dispatch.bind(null, updateDevice), "new", "Device"),
-            DELETE: createEventHandler(dispatch.bind(null, deleteDevice), "old", "Device"),
+            INSERT: (payload) => {
+                if (payload.new)
+                    dispatch(addDevice(payload.new));
+            },
+            UPDATE: (payload) => {
+                if (payload.new)
+                    dispatch(updateDevice(payload.new));
+            },
+            DELETE: (payload) => {
+                if (payload.old)
+                    dispatch(deleteDevice(payload.old));
+            },
         },
         plans: {
-            INSERT: createEventHandler(dispatch.bind(null, addPlan), "new", "Plan"),
-            UPDATE: createEventHandler(dispatch.bind(null, updatePlan), "new", "Plan"),
-            DELETE: createEventHandler(dispatch.bind(null, deletePlan), "old", "Plan"),
+            INSERT: (payload) => {
+                if (payload.new)
+                    dispatch(addPlan(payload.new));
+            },
+            UPDATE: (payload) => {
+                if (payload.new)
+                    dispatch(updatePlan(payload.new));
+            },
+            DELETE: (payload) => {
+                if (payload.old)
+                    dispatch(deletePlan(payload.old));
+            },
         },
         sessions: {
-            INSERT: createEventHandler(dispatch.bind(null, addSessionToStore), "new", "Session"),
-            UPDATE: createEventHandler(dispatch.bind(null, updateSessionInStore), "new", "Session"),
-            DELETE: createEventHandler(dispatch.bind(null, deleteSessionFromStore), "old", "Session"),
+            INSERT: (payload) => console.log("[DB Listener] Session INSERT:", payload),
+            UPDATE: (payload) => console.log("[DB Listener] Session UPDATE:", payload),
+            DELETE: (payload) => console.log("[DB Listener] Session DELETE:", payload),
         },
         connectivity: {
-            INSERT: (payload) => console.log("[DB Listener] Connectivity INSERT received:", payload),
-            UPDATE: (payload) => console.log("[DB Listener] Connectivity UPDATE received:", payload),
-            DELETE: (payload) => console.log("[DB Listener] Connectivity DELETE received:", payload),
+            INSERT: (payload) => console.log("[DB Listener] Connectivity INSERT:", payload),
+            UPDATE: (payload) => console.log("[DB Listener] Connectivity UPDATE:", payload),
+            DELETE: (payload) => console.log("[DB Listener] Connectivity DELETE:", payload),
         },
-    }), [createEventHandler, dispatch]);
-    // Create a channel with proper error handling
-    const createChannel = useCallback((tableName) => {
-        if (!supabase.current)
-            return null;
-        const channelName = `scout_broadcast_${tableName}_${Date.now()}`;
-        console.log(`[DB Listener] Creating broadcast channel for ${tableName}:`, channelName);
-        try {
-            const channel = supabase.current.channel(channelName, {
-                config: { private: true },
-            });
-            // Add system event handlers for connection monitoring
-            channel
-                .on("system", { event: "disconnect" }, () => {
-                console.log(`[DB Listener] 🔌 ${tableName} channel disconnected`);
-                setConnectionState(ConnectionState.DISCONNECTED);
-                setLastError("Channel disconnected");
-            })
-                .on("system", { event: "reconnect" }, () => {
-                console.log(`[DB Listener] 🔗 ${tableName} channel reconnected`);
-            })
-                .on("system", { event: "error" }, (error) => {
-                console.warn(`[DB Listener] ❌ ${tableName} channel error:`, error);
-                setLastError(`Channel error: ${error}`);
-            });
-            return channel;
-        }
-        catch (error) {
-            console.error(`[DB Listener] Failed to create ${tableName} channel:`, error);
-            return null;
-        }
-    }, []);
-    // Set up all channels
-    const setupChannels = useCallback(async () => {
-        if (!supabase.current)
+    };
+    // Set up channels
+    const setupChannels = async () => {
+        if (!scoutSupabase)
             return false;
         cleanupChannels();
-        const tableHandlers = handlers();
-        const tables = Object.keys(tableHandlers);
+        const tables = Object.keys(handlers);
         let successCount = 0;
         const totalChannels = tables.length;
         for (const tableName of tables) {
-            const channel = createChannel(tableName);
-            if (!channel)
-                continue;
             try {
+                const channelName = `scout_broadcast_${tableName}_${Date.now()}`;
+                const channel = scoutSupabase.channel(channelName, {
+                    config: { private: false },
+                });
                 // Set up event handlers
-                const tableHandler = tableHandlers[tableName];
+                const tableHandler = handlers[tableName];
                 Object.entries(tableHandler).forEach(([event, handler]) => {
                     channel.on("broadcast", { event }, handler);
                 });
                 // Subscribe to the channel
                 channel.subscribe((status) => {
-                    console.log(`[DB Listener] ${tableName} channel status:`, status);
                     if (status === "SUBSCRIBED") {
                         successCount++;
                         if (successCount === totalChannels) {
                             setConnectionState(ConnectionState.CONNECTED);
-                            setRetryCount(0);
                             setLastError(null);
-                            console.log("[DB Listener] ✅ All channels successfully subscribed");
                         }
                     }
                     else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
-                        console.error(`[DB Listener] ${tableName} channel failed to subscribe:`, status);
                         setLastError(`Channel subscription failed: ${status}`);
                     }
                 });
@@ -220,107 +126,44 @@ export function useScoutDbListener(scoutSupabase) {
             }
         }
         return successCount > 0;
-    }, [cleanupChannels, createChannel, handlers]);
-    // Schedule reconnection with exponential backoff
-    const scheduleReconnection = useCallback(() => {
-        if (isDestroyedRef.current ||
-            retryCount >= RECONNECTION_CONFIG.MAX_RETRIES) {
-            console.log("[DB Listener] Max reconnection attempts reached or hook destroyed");
-            setConnectionState(ConnectionState.ERROR);
-            return;
-        }
-        const delay = calculateBackoffDelay(retryCount);
-        console.log(`[DB Listener] Scheduling reconnection attempt ${retryCount + 1} in ${delay}ms`);
-        reconnectTimeoutRef.current = setTimeout(() => {
-            if (!isDestroyedRef.current) {
-                initializeConnection();
-            }
-        }, delay);
-    }, [retryCount, calculateBackoffDelay]);
+    };
     // Initialize connection
-    const initializeConnection = useCallback(async () => {
-        if (isDestroyedRef.current || isInitializingRef.current)
+    const initializeConnection = async () => {
+        if (!scoutSupabase)
             return;
-        isInitializingRef.current = true;
         setConnectionState(ConnectionState.CONNECTING);
         try {
-            console.log("[DB Listener] 🔄 Initializing connection...");
             // Test database connection
-            const dbConnected = await testDbConnection();
-            if (!dbConnected) {
+            const { error } = await scoutSupabase.from("tags").select("id").limit(1);
+            if (error) {
                 throw new Error("Database connection test failed");
             }
-            // Set up realtime authentication
-            const authSuccess = await setupRealtimeAuth();
-            if (!authSuccess) {
-                throw new Error("Realtime authentication failed");
-            }
             // Set up channels
-            const channelsSuccess = await setupChannels();
-            if (!channelsSuccess) {
+            const success = await setupChannels();
+            if (!success) {
                 throw new Error("Channel setup failed");
             }
-            console.log("[DB Listener] ✅ Connection initialized successfully");
         }
         catch (error) {
-            console.error("[DB Listener] ❌ Connection initialization failed:", error);
             setLastError(error instanceof Error ? error.message : "Unknown error");
             setConnectionState(ConnectionState.ERROR);
-            setRetryCount((prev) => prev + 1);
-            // Schedule reconnection
-            scheduleReconnection();
         }
-        finally {
-            isInitializingRef.current = false;
-        }
-    }, [
-        testDbConnection,
-        setupRealtimeAuth,
-        setupChannels,
-        scheduleReconnection,
-    ]);
-    // Manual reconnection function
-    const reconnect = useCallback(() => {
-        if (isDestroyedRef.current)
-            return;
-        console.log("[DB Listener] 🔄 Manual reconnection requested");
-        cancelReconnection();
-        setRetryCount(0);
-        setLastError(null);
-        initializeConnection();
-    }, [cancelReconnection, initializeConnection]);
+    };
     // Main effect
     useEffect(() => {
-        console.log("=== SCOUT DB LISTENER INITIALIZATION ===");
         if (!scoutSupabase) {
-            console.error("[DB Listener] No Supabase client available");
             setConnectionState(ConnectionState.ERROR);
             setLastError("No Supabase client available");
             return;
         }
-        supabase.current = scoutSupabase;
-        isDestroyedRef.current = false;
-        // Initialize connection
         initializeConnection();
-        // Cleanup function
         return () => {
-            console.log("[DB Listener] 🧹 Cleaning up hook");
-            isDestroyedRef.current = true;
-            cancelReconnection();
             cleanupChannels();
         };
-    }, [
-        scoutSupabase,
-        initializeConnection,
-        cancelReconnection,
-        cleanupChannels,
-    ]);
-    // Return connection state and manual reconnect function
+    }, [scoutSupabase]);
     return {
         connectionState,
         lastError,
-        retryCount,
-        reconnect,
         isConnected: connectionState === ConnectionState.CONNECTED,
         isConnecting: connectionState === ConnectionState.CONNECTING,
     };

package/dist/index.d.ts

@@ -33,7 +33,6 @@ export * from "./hooks/useScoutRefresh";
 export * from "./providers";
 export * from "./store/scout";
 export * from "./store/hooks";
-export * from "./supabase/client";
 export * from "./supabase/middleware";
 export * from "./supabase/server";
 export * from "./api_keys/actions";

package/dist/index.js

@@ -40,7 +40,6 @@ export * from "./providers";
 export * from "./store/scout";
 export * from "./store/hooks";
 // Supabase
-export * from "./supabase/client";
 export * from "./supabase/middleware";
 export * from "./supabase/server";
 // API Keys

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -744,6 +744,40 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
             };
             Returns: string[];
         };
+        load_api_keys_batch: {
+            Args: {
+                device_ids: number[];
+            };
+            Returns: {
+                device_id: number;
+                api_key_id: number;
+                api_key_key: string;
+            }[];
+        };
+        get_events_and_tags_for_devices_batch: {
+            Args: {
+                device_ids: number[];
+                limit_per_device: number;
+            };
+            Returns: {
+                event_id: number;
+                inserted_at: string;
+                message: string | null;
+                media_url: string | null;
+                file_path: string | null;
+                latitude: number | null;
+                longitude: number | null;
+                earthranger_url: string | null;
+                altitude: number;
+                heading: number;
+                media_type: string;
+                device_id: number;
+                timestamp_observation: string;
+                is_public: boolean;
+                tags: import("../types/supabase").Json;
+                herd_id: number | null;
+            }[];
+        };
     };
     Enums: {
         app_permission: "herds.delete" | "events.delete";

package/dist/supabase/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./client";
 export * from "./middleware";
 export * from "./server";

package/dist/supabase/index.js

@@ -1,3 +1,2 @@
-export * from "./client";
 export * from "./middleware";
 export * from "./server";

package/dist/supabase/server.d.ts

@@ -735,6 +735,40 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
             };
             Returns: string[];
         };
+        load_api_keys_batch: {
+            Args: {
+                device_ids: number[];
+            };
+            Returns: {
+                device_id: number;
+                api_key_id: number;
+                api_key_key: string;
+            }[];
+        };
+        get_events_and_tags_for_devices_batch: {
+            Args: {
+                device_ids: number[];
+                limit_per_device: number;
+            };
+            Returns: {
+                event_id: number;
+                inserted_at: string;
+                message: string | null;
+                media_url: string | null;
+                file_path: string | null;
+                latitude: number | null;
+                longitude: number | null;
+                earthranger_url: string | null;
+                altitude: number;
+                heading: number;
+                media_type: string;
+                device_id: number;
+                timestamp_observation: string;
+                is_public: boolean;
+                tags: import("../types/supabase").Json;
+                herd_id: number | null;
+            }[];
+        };
     };
     Enums: {
         app_permission: "herds.delete" | "events.delete";

package/dist/types/db.d.ts

@@ -55,7 +55,6 @@ export type IUserAndRole = {
 };
 export interface IApiKeyScout {
     id: string;
-    description: string;
     key: string;
 }
 export type Tag = ITag;

package/dist/types/herd_module.js

@@ -3,11 +3,11 @@ import { get_devices_by_herd } from "../helpers/devices";
 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_events_and_tags_for_device } from "../helpers/tags";
+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";
 import { server_get_more_zones_and_actions_for_herd } from "../helpers/zones";
-import { server_list_api_keys } from "../api_keys/actions";
+import { server_list_api_keys_batch } from "../api_keys/actions";
 import { getSessionsByHerdId } from "../helpers/sessions";
 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 = []) {
@@ -56,31 +56,37 @@ export class HerdModule {
                 return new HerdModule(herd, [], [], Date.now());
             }
             const new_devices = response_new_devices.data;
-            // get api keys for each device... run requests in parallel
+            // get api keys and events for all devices in batch
+            let recent_events_batch = {};
             if (new_devices.length > 0) {
                 try {
-                    let api_keys_promises = new_devices.map((device) => server_list_api_keys(device.id?.toString() ?? "").catch((error) => {
-                        console.warn(`Failed to get API keys for device ${device.id}:`, error);
-                        return undefined;
-                    }));
-                    let api_keys = await Promise.all(api_keys_promises);
+                    const device_ids = new_devices.map((device) => device.id ?? 0);
+                    console.log(`[HerdModule] Loading batch data for ${device_ids.length} devices:`, device_ids);
+                    // Load API keys and events in parallel
+                    const [api_keys_batch, events_response] = await Promise.all([
+                        server_list_api_keys_batch(device_ids),
+                        server_get_events_and_tags_for_devices_batch(device_ids, 1),
+                    ]);
+                    // Assign API keys to devices
                     for (let i = 0; i < new_devices.length; i++) {
-                        new_devices[i].api_keys_scout = api_keys[i];
+                        const device_id = new_devices[i].id ?? 0;
+                        new_devices[i].api_keys_scout = api_keys_batch[device_id] || [];
+                    }
+                    console.log(`[HerdModule] API keys loaded for ${Object.keys(api_keys_batch).length} devices`);
+                    // Process events response
+                    if (events_response.status === EnumWebResponse.SUCCESS &&
+                        events_response.data) {
+                        recent_events_batch = events_response.data;
+                        console.log(`[HerdModule] Events loaded for ${Object.keys(recent_events_batch).length} devices`);
                     }
                 }
                 catch (error) {
-                    console.warn("Failed to load API keys for devices:", error);
-                    // Continue without API keys
+                    console.warn("Failed to load API keys or events for devices:", error);
+                    // Continue without API keys and events
                 }
             }
-            // get recent events for each device... run requests in parallel
-            let recent_events_promises = new_devices.map((device) => server_get_events_and_tags_for_device(device.id ?? 0).catch((error) => {
-                console.warn(`Failed to get events for device ${device.id}:`, error);
-                return { status: EnumWebResponse.ERROR, data: null };
-            }));
-            // Run all requests in parallel with individual error handling
-            const [recent_events, res_zones, res_user_roles, total_event_count, res_plans, res_sessions,] = await Promise.allSettled([
-                Promise.all(recent_events_promises),
+            // Run all remaining requests in parallel with individual error handling
+            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions,] = await Promise.allSettled([
                 server_get_more_zones_and_actions_for_herd(herd.id, 0, 10).catch((error) => {
                     console.warn("Failed to get zones and actions:", error);
                     return { status: EnumWebResponse.ERROR, data: null };
@@ -102,20 +108,18 @@ export class HerdModule {
                     return [];
                 }),
             ]);
-            // Process recent events with error handling
-            if (recent_events.status === "fulfilled") {
-                for (let i = 0; i < new_devices.length; i++) {
-                    try {
-                        let x = recent_events.value[i]?.data;
-                        if (recent_events.value[i]?.status == EnumWebResponse.SUCCESS &&
-                            x) {
-                            new_devices[i].recent_events = x;
-                        }
-                    }
-                    catch (error) {
-                        console.warn(`Failed to process events for device ${new_devices[i].id}:`, error);
+            // Assign recent events to devices from batch results
+            for (let i = 0; i < new_devices.length; i++) {
+                try {
+                    const device_id = new_devices[i].id ?? 0;
+                    const events = recent_events_batch[device_id];
+                    if (events) {
+                        new_devices[i].recent_events = events;
                     }
                 }
+                catch (error) {
+                    console.warn(`Failed to process events for device ${new_devices[i].id}:`, error);
+                }
             }
             // Extract data with safe fallbacks
             const zones = res_zones.status === "fulfilled" && res_zones.value?.data

package/dist/types/supabase.d.ts

@@ -802,6 +802,40 @@ export type Database = {
                 };
                 Returns: string[];
             };
+            load_api_keys_batch: {
+                Args: {
+                    device_ids: number[];
+                };
+                Returns: {
+                    device_id: number;
+                    api_key_id: number;
+                    api_key_key: string;
+                }[];
+            };
+            get_events_and_tags_for_devices_batch: {
+                Args: {
+                    device_ids: number[];
+                    limit_per_device: number;
+                };
+                Returns: {
+                    event_id: number;
+                    inserted_at: string;
+                    message: string | null;
+                    media_url: string | null;
+                    file_path: string | null;
+                    latitude: number | null;
+                    longitude: number | null;
+                    earthranger_url: string | null;
+                    altitude: number;
+                    heading: number;
+                    media_type: string;
+                    device_id: number;
+                    timestamp_observation: string;
+                    is_public: boolean;
+                    tags: Json;
+                    herd_id: number | null;
+                }[];
+            };
         };
         Enums: {
             app_permission: "herds.delete" | "events.delete";

package/package.json

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

package/dist/supabase/client.d.ts

@@ -1 +0,0 @@
-export declare function newClient(): Promise<import("@supabase/supabase-js").SupabaseClient<any, "public", any>>;

package/dist/supabase/client.js

@@ -1,5 +0,0 @@
-import { createClient } from "@supabase/supabase-js";
-export async function newClient() {
-    const client = await createClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY);
-    return client;
-}