@adventurelabs/scout-core 1.0.54 → 1.0.56

package/dist/helpers/events.d.ts

@@ -1,7 +1,3 @@
-import { IEvent } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
-export declare function server_get_events_by_herd(herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<IEvent[]>>;
-export declare function server_get_more_events_by_herd(herd_id: number, offset: number, page_count: number | undefined, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<IEvent[]>>;
 export declare function server_get_total_events_by_herd(herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<number>>;
-export declare function server_create_event(newEvent: any): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/events.js

@@ -1,79 +1,16 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { addSignedUrlsToEvents } from "./storage";
 import { EnumSessionsVisibility } from "../types/events";
-export async function server_get_events_by_herd(herd_id, sessions_visibility) {
-    const supabase = await newServerClient();
-    // fetch events and include devices
-    // sort by timestamp
-    let query = supabase
-        .from("events")
-        .select(`
-      *,
-      devices: devices!inner(*)
-      `)
-        .eq("devices.herd_id", herd_id);
-    // Apply session filter based on sessions_visibility
-    if (sessions_visibility === EnumSessionsVisibility.Only) {
-        query = query.not("session_id", "is", null);
-    }
-    else if (sessions_visibility === EnumSessionsVisibility.Exclude) {
-        query = query.is("session_id", null);
-    }
-    const { data } = await query.order("timestamp_observation", { ascending: false });
-    // Add signed URLs to events using the same client
-    const eventsWithSignedUrls = data
-        ? await addSignedUrlsToEvents(data, supabase)
-        : [];
-    // TODO: DETERMINE WHEN TO PASS ERROR
-    let response = IWebResponse.success(eventsWithSignedUrls);
-    return response.to_compatible();
-}
-export async function server_get_more_events_by_herd(herd_id, offset, page_count = 10, sessions_visibility) {
-    const from = offset * page_count;
-    const to = from + page_count - 1;
-    const supabase = await newServerClient();
-    // fetch events and include devices
-    // sort by timestamp
-    let query = supabase
-        .from("events")
-        .select(`
-      *,
-      devices: devices!inner(*)
-      `)
-        .eq("devices.herd_id", herd_id)
-        .range(from, to);
-    // Apply session filter based on sessions_visibility
-    if (sessions_visibility === EnumSessionsVisibility.Only) {
-        query = query.not("session_id", "is", null);
-    }
-    else if (sessions_visibility === EnumSessionsVisibility.Exclude) {
-        query = query.is("session_id", null);
-    }
-    const { data } = await query.order("timestamp_observation", { ascending: false });
-    // Add signed URLs to events using the same client
-    const eventsWithSignedUrls = data
-        ? await addSignedUrlsToEvents(data, supabase)
-        : [];
-    // TODO: DETERMINE WHEN TO PASS ERROR
-    let response = IWebResponse.success(eventsWithSignedUrls);
-    return response.to_compatible();
-}
 // function to get total number of events for a herd
 export async function server_get_total_events_by_herd(herd_id, sessions_visibility) {
     const supabase = await newServerClient();
-    let query = supabase
-        .from("events")
-        .select("id", { count: "exact", head: true })
-        .eq("devices.herd_id", herd_id);
-    if (sessions_visibility === EnumSessionsVisibility.Only) {
-        query = query.not("session_id", "is", null);
-    }
-    else if (sessions_visibility === EnumSessionsVisibility.Exclude) {
-        query = query.is("session_id", null);
-    }
-    const { count, error } = await query;
+    // Convert sessions_visibility to exclude_session_events boolean
+    const exclude_session_events = sessions_visibility === EnumSessionsVisibility.Exclude;
+    const { data, error } = (await supabase.rpc("get_total_events_for_herd_with_session_filter", {
+        herd_id_caller: herd_id,
+        exclude_session_events: exclude_session_events,
+    }));
     if (error) {
         return {
             status: EnumWebResponse.ERROR,
@@ -82,21 +19,6 @@ export async function server_get_total_events_by_herd(herd_id, sessions_visibili
         };
     }
     else {
-        return IWebResponse.success(count || 0).to_compatible();
-    }
-}
-export async function server_create_event(newEvent) {
-    const supabase = await newServerClient();
-    // strip id field from herd object
-    const { data, error } = await supabase.from("events").insert([newEvent]);
-    if (error) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: null,
-        };
-    }
-    else {
-        return IWebResponse.success(true).to_compatible();
+        return IWebResponse.success(data || 0).to_compatible();
     }
 }

package/dist/helpers/tags.d.ts

@@ -1,6 +1,5 @@
 import { IEventWithTags, ITag } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-export declare function test_event_loading(device_id: number): Promise<boolean>;
 export declare function server_create_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
 export declare function server_delete_tags_by_ids(tag_ids: number[]): Promise<IWebResponseCompatible<boolean>>;
 export declare function server_update_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;

package/dist/helpers/tags.js

@@ -3,25 +3,6 @@
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { addSignedUrlsToEvents, addSignedUrlToEvent } from "./storage";
-// Test function to verify individual event loading works
-export async function test_event_loading(device_id) {
-    try {
-        console.log(`[Event Test] Testing individual event loading for device ${device_id}`);
-        const events_response = await server_get_events_and_tags_for_device(device_id, 1);
-        if (events_response.status === EnumWebResponse.SUCCESS) {
-            console.log(`[Event Test] Successfully loaded ${events_response.data?.length || 0} events for device ${device_id}`);
-            return true;
-        }
-        else {
-            console.error(`[Event Test] Failed to load events for device ${device_id}:`, events_response.msg);
-            return false;
-        }
-    }
-    catch (error) {
-        console.error(`[Event Test] Failed to load events for device ${device_id}:`, error);
-        return false;
-    }
-}
 export async function server_create_tags(tags) {
     const supabase = await newServerClient();
     // remove id key from tags
@@ -94,29 +75,6 @@ export async function server_update_tags(tags) {
     }
     return IWebResponse.success(updatedTags).to_compatible();
 }
-// export async function server_get_events_with_tags_by_herd(
-//   herd_id: number
-// ): Promise<IWebResponseCompatible<IEventWithTags[]>> {
-//   const supabase = await newServerClient();
-//   const { data, error } = await supabase
-//     .from("events")
-//     .select(
-//       `
-//       *,
-//       tags: tags (*)
-//       `
-//     )
-//     .eq("devices.herd_id", herd_id)
-//     .order("timestamp_observation", { ascending: false });
-//   if (error) {
-//     return {
-//       status: EnumWebResponse.ERROR,
-//       msg: error.message,
-//       data: [],
-//     };
-//   }
-//   return IWebResponse.success(data).to_compatible();
-// }
 export async function server_get_more_events_with_tags_by_herd(herd_id, offset, page_count = 10) {
     const from = offset * page_count;
     const to = from + page_count - 1;

package/dist/hooks/useScoutDbListener.d.ts

@@ -1,18 +1,3 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-declare enum ConnectionState {
-    DISCONNECTED = "disconnected",
-    CONNECTING = "connecting",
-    CONNECTED = "connected",
-    ERROR = "error"
-}
-/**
- * Hook for listening to real-time database changes
- */
-export declare function useScoutDbListener(scoutSupabase: SupabaseClient<Database>): {
-    connectionState: ConnectionState;
-    lastError: string | null;
-    isConnected: boolean;
-    isConnecting: boolean;
-};
-export {};
+export declare function useScoutDbListener(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutDbListener.js

@@ -1,170 +1,177 @@
 "use client";
 import { useAppDispatch } from "../store/hooks";
-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) {
-    ConnectionState["DISCONNECTED"] = "disconnected";
-    ConnectionState["CONNECTING"] = "connecting";
-    ConnectionState["CONNECTED"] = "connected";
-    ConnectionState["ERROR"] = "error";
-})(ConnectionState || (ConnectionState = {}));
-/**
- * Hook for listening to real-time database changes
- */
+import { useEffect, useRef } from "react";
+import { addDevice, addPlan, addTag, addSessionToStore, deleteDevice, deletePlan, deleteSessionFromStore, deleteTag, updateDevice, updatePlan, updateSessionInStore, updateTag, } from "../store/scout";
 export function useScoutDbListener(scoutSupabase) {
+    const supabase = useRef(null);
     const channels = useRef([]);
     const dispatch = useAppDispatch();
-    const [connectionState, setConnectionState] = useState(ConnectionState.DISCONNECTED);
-    const [lastError, setLastError] = useState(null);
+    const reconnectTimeoutRef = useRef(null);
+    const reconnectAttemptsRef = useRef(0);
+    const maxReconnectAttempts = 10;
+    const baseDelay = 1000; // 1 second
+    const maxDelay = 5000; // 5 seconds
+    function handleTagInserts(payload) {
+        console.log("[DB Listener] Tag INSERT received:", payload.new);
+        dispatch(addTag(payload.new));
+    }
+    function handleTagDeletes(payload) {
+        console.log("[DB Listener] Tag DELETE received:", payload.old);
+        if (!payload.old || !payload.old.id) {
+            console.error("[DB Listener] Tag DELETE - Invalid payload, missing tag data");
+            return;
+        }
+        dispatch(deleteTag(payload.old));
+    }
+    function handleTagUpdates(payload) {
+        console.log("[DB Listener] Tag UPDATE received:", payload.new);
+        dispatch(updateTag(payload.new));
+    }
+    function handleDeviceInserts(payload) {
+        console.log("[DB Listener] Device INSERT received:", payload.new);
+        dispatch(addDevice(payload.new));
+    }
+    function handleDeviceDeletes(payload) {
+        console.log("[DB Listener] Device DELETE received:", payload.old);
+        dispatch(deleteDevice(payload.old));
+    }
+    function handleDeviceUpdates(payload) {
+        console.log("[DB Listener] Device UPDATE received:", payload.new);
+        dispatch(updateDevice(payload.new));
+    }
+    function handlePlanInserts(payload) {
+        console.log("[DB Listener] Plan INSERT received:", payload.new);
+        dispatch(addPlan(payload.new));
+    }
+    function handlePlanDeletes(payload) {
+        console.log("[DB Listener] Plan DELETE received:", payload.old);
+        dispatch(deletePlan(payload.old));
+    }
+    function handlePlanUpdates(payload) {
+        console.log("[DB Listener] Plan UPDATE received:", payload.new);
+        dispatch(updatePlan(payload.new));
+    }
+    function handleSessionInserts(payload) {
+        console.log("[DB Listener] Session INSERT received:", payload.new);
+        dispatch(addSessionToStore(payload.new));
+    }
+    function handleSessionDeletes(payload) {
+        console.log("[DB Listener] Session DELETE received:", payload.old);
+        if (!payload.old || !payload.old.id) {
+            console.error("[DB Listener] Session DELETE - Invalid payload, missing session data");
+            return;
+        }
+        dispatch(deleteSessionFromStore(payload.old));
+    }
+    function handleSessionUpdates(payload) {
+        console.log("[DB Listener] Session UPDATE received:", payload.new);
+        dispatch(updateSessionInStore(payload.new));
+    }
+    function handleConnectivityInserts(payload) {
+        console.log("[DB Listener] Connectivity INSERT received:", payload.new);
+    }
+    function handleConnectivityDeletes(payload) {
+        console.log("[DB Listener] Connectivity DELETE received:", payload.old);
+    }
+    function handleConnectivityUpdates(payload) {
+        console.log("[DB Listener] Connectivity UPDATE received:", payload.new);
+    }
     // Clean up all channels
     const cleanupChannels = () => {
         channels.current.forEach((channel) => {
-            if (channel && scoutSupabase) {
-                try {
-                    scoutSupabase.removeChannel(channel);
-                }
-                catch (error) {
-                    console.warn("[DB Listener] Error removing channel:", error);
-                }
+            if (channel) {
+                scoutSupabase.removeChannel(channel);
             }
         });
         channels.current = [];
     };
-    // Create event handlers
-    const handlers = {
-        tags: {
-            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: (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: (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: (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:", payload),
-            UPDATE: (payload) => console.log("[DB Listener] Connectivity UPDATE:", payload),
-            DELETE: (payload) => console.log("[DB Listener] Connectivity DELETE:", payload),
-        },
-    };
-    // Set up channels
-    const setupChannels = async () => {
+    // Setup channel with event handlers
+    const setupChannel = () => {
         if (!scoutSupabase)
-            return false;
-        cleanupChannels();
-        const tables = Object.keys(handlers);
-        let successCount = 0;
-        const totalChannels = tables.length;
-        for (const tableName of tables) {
-            try {
-                const channelName = `scout_broadcast_${tableName}_${Date.now()}`;
-                const channel = scoutSupabase.channel(channelName, {
-                    config: { private: false },
-                });
-                // Set up event handlers
-                const tableHandler = handlers[tableName];
-                Object.entries(tableHandler).forEach(([event, handler]) => {
-                    channel.on("broadcast", { event }, handler);
-                });
-                // Subscribe to the channel
-                channel.subscribe((status) => {
-                    if (status === "SUBSCRIBED") {
-                        successCount++;
-                        if (successCount === totalChannels) {
-                            setConnectionState(ConnectionState.CONNECTED);
-                            setLastError(null);
-                        }
-                    }
-                    else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
-                        setLastError(`Channel subscription failed: ${status}`);
-                    }
-                });
-                channels.current.push(channel);
+            return null;
+        const mainChannel = scoutSupabase.channel("schema_db_changes");
+        // Subscribe to all events
+        mainChannel
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "plans" }, handlePlanInserts)
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "plans" }, handlePlanDeletes)
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "plans" }, handlePlanUpdates)
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "devices" }, handleDeviceInserts)
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "devices" }, handleDeviceDeletes)
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "devices" }, handleDeviceUpdates)
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "tags" }, handleTagInserts)
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "tags" }, handleTagDeletes)
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "tags" }, handleTagUpdates)
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "connectivity" }, handleConnectivityInserts)
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "connectivity" }, handleConnectivityDeletes)
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "connectivity" }, handleConnectivityUpdates)
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "sessions" }, handleSessionInserts)
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "sessions" }, handleSessionDeletes)
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "sessions" }, handleSessionUpdates)
+            .subscribe((status) => {
+            console.log("[DB Listener] Subscription status:", status);
+            if (status === "SUBSCRIBED") {
+                console.log("[DB Listener] ✅ Successfully subscribed to real-time updates");
+                reconnectAttemptsRef.current = 0; // Reset reconnect attempts on successful connection
             }
-            catch (error) {
-                console.error(`[DB Listener] Failed to set up ${tableName} channel:`, error);
+            else if (status === "CHANNEL_ERROR") {
+                console.error("[DB Listener] ❌ Channel error occurred. Reconnecting...");
+                handleReconnect();
             }
-        }
-        return successCount > 0;
-    };
-    // Initialize connection
-    const initializeConnection = async () => {
-        if (!scoutSupabase)
-            return;
-        setConnectionState(ConnectionState.CONNECTING);
-        try {
-            // Test database connection
-            const { error } = await scoutSupabase.from("tags").select("id").limit(1);
-            if (error) {
-                throw new Error("Database connection test failed");
+            else if (status === "TIMED_OUT") {
+                console.error("[DB Listener] ⏰ Subscription timed out. Reconnecting...");
+                handleReconnect();
             }
-            // Set up channels
-            const success = await setupChannels();
-            if (!success) {
-                throw new Error("Channel setup failed");
+            else if (status === "CLOSED") {
+                console.log("[DB Listener] 🔒 Channel closed. Reconnecting...");
+                handleReconnect();
             }
+        });
+        return mainChannel;
+    };
+    // Handle reconnection with exponential backoff
+    const handleReconnect = () => {
+        if (reconnectAttemptsRef.current >= maxReconnectAttempts) {
+            console.error("[DB Listener] 🚫 Max reconnection attempts reached");
+            return;
         }
-        catch (error) {
-            setLastError(error instanceof Error ? error.message : "Unknown error");
-            setConnectionState(ConnectionState.ERROR);
+        // Clear any existing timeout
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
         }
+        const delay = Math.min(baseDelay * (reconnectAttemptsRef.current + 1), maxDelay);
+        console.log(`[DB Listener] 🔄 Attempting reconnection in ${delay}ms (attempt ${reconnectAttemptsRef.current + 1}/${maxReconnectAttempts})`);
+        reconnectTimeoutRef.current = setTimeout(() => {
+            reconnectAttemptsRef.current++;
+            cleanupChannels();
+            const newChannel = setupChannel();
+            if (newChannel) {
+                channels.current.push(newChannel);
+            }
+        }, delay);
     };
-    // Main effect
     useEffect(() => {
         if (!scoutSupabase) {
-            setConnectionState(ConnectionState.ERROR);
-            setLastError("No Supabase client available");
+            console.error("[DB Listener] No Supabase client available");
             return;
         }
-        initializeConnection();
+        supabase.current = scoutSupabase;
+        // Initial channel setup
+        const mainChannel = setupChannel();
+        if (mainChannel) {
+            channels.current.push(mainChannel);
+        }
+        // Cleanup function
         return () => {
+            console.log("[DB Listener] 🧹 Cleaning up channels");
+            // Clear any pending reconnection attempts
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+                reconnectTimeoutRef.current = null;
+            }
+            // Reset reconnect attempts
+            reconnectAttemptsRef.current = 0;
+            // Clean up channels
             cleanupChannels();
         };
-    }, [scoutSupabase]);
-    return {
-        connectionState,
-        lastError,
-        isConnected: connectionState === ConnectionState.CONNECTED,
-        isConnecting: connectionState === ConnectionState.CONNECTING,
-    };
+    }, [scoutSupabase, dispatch]);
 }

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -716,6 +716,13 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
             };
             Returns: number;
         };
+        get_total_events_for_herd_with_session_filter: {
+            Args: {
+                herd_id_caller: number;
+                exclude_session_events: boolean;
+            };
+            Returns: number;
+        };
         get_zones_and_actions_for_herd: {
             Args: {
                 herd_id_caller: number;

package/dist/supabase/server.d.ts

@@ -707,6 +707,13 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
             };
             Returns: number;
         };
+        get_total_events_for_herd_with_session_filter: {
+            Args: {
+                herd_id_caller: number;
+                exclude_session_events: boolean;
+            };
+            Returns: number;
+        };
         get_zones_and_actions_for_herd: {
             Args: {
                 herd_id_caller: number;

package/dist/types/supabase.d.ts

@@ -776,6 +776,13 @@ export type Database = {
                 };
                 Returns: number;
             };
+            get_total_events_for_herd_with_session_filter: {
+                Args: {
+                    herd_id_caller: number;
+                    exclude_session_events: boolean;
+                };
+                Returns: number;
+            };
             get_zones_and_actions_for_herd: {
                 Args: {
                     herd_id_caller: number;

package/package.json

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