@adventurelabs/scout-core 1.0.88 → 1.0.90

package/dist/helpers/connectivity.d.ts

@@ -0,0 +1,4 @@
+import { IWebResponseCompatible } from "../types/requests";
+import { IConnectivityWithCoordinates } from "../types/db";
+export declare function server_get_connectivity_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
+export declare function server_get_connectivity_by_device_id(deviceId: number, timestamp: string): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;

package/dist/helpers/connectivity.js

@@ -0,0 +1,45 @@
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+// Get connectivity by session id using RPC function with coordinates
+export async function server_get_connectivity_by_session_id(sessionId) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates", { session_id_caller: sessionId });
+    if (error) {
+        console.warn("Error fetching connectivity by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    // Sort by timestamp_start in ascending order
+    const sortedConnectivity = (data || []).sort((a, b) => {
+        if (!a.timestamp_start || !b.timestamp_start)
+            return 0;
+        return (new Date(a.timestamp_start).getTime() -
+            new Date(b.timestamp_start).getTime());
+    });
+    return IWebResponse.success(sortedConnectivity).to_compatible();
+}
+// Get all connectivity items after a specific timestamp, filtered by device ID
+// Timestamp should be formatted as YYYY-MM-DDTHH:mm:ss.SSSZ
+export async function server_get_connectivity_by_device_id(deviceId, timestamp) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates_by_device_and_timestamp", { device_id_caller: deviceId, timestamp_filter: timestamp });
+    if (error) {
+        console.warn("Error fetching connectivity by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    // Sort by timestamp_start in ascending order
+    const sortedConnectivity = (data || []).sort((a, b) => {
+        if (!a.timestamp_start || !b.timestamp_start)
+            return 0;
+        return (new Date(a.timestamp_start).getTime() -
+            new Date(b.timestamp_start).getTime());
+    });
+    return IWebResponse.success(sortedConnectivity).to_compatible();
+}

package/dist/helpers/devices.d.ts

@@ -1,4 +1,4 @@
-import { Database } from "@/types";
+import { Database } from "../types/supabase";
 import { DeviceInsert, IDevice } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";

package/dist/helpers/sessions.d.ts

@@ -11,7 +11,6 @@ export type ConnectivityUpdateInput = Partial<ConnectivityInput> & {
 };
 export type ConnectivityUpsertInput = ConnectivityInput | ConnectivityUpdateInput;
 export declare function server_get_sessions_by_herd_id(herdId: number): Promise<IWebResponseCompatible<ISessionWithCoordinates[]>>;
-export declare function server_get_connectivity_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IConnectivityWithCoordinates[]>>;
 export declare function server_get_events_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IEvent[]>>;
 export declare function server_get_events_and_tags_by_session_id(sessionId: number, limit?: number, offset?: number): Promise<IWebResponseCompatible<IEventAndTagsPrettyLocation[]>>;
 export declare function server_get_total_events_for_session(sessionId: number): Promise<IWebResponseCompatible<number>>;

package/dist/helpers/sessions.js

@@ -1,6 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
+import { server_get_connectivity_by_session_id } from "./connectivity";
 // Get sessions by herd id using RPC function with coordinates
 export async function server_get_sessions_by_herd_id(herdId) {
     const supabase = await newServerClient();
@@ -24,27 +25,6 @@ export async function server_get_sessions_by_herd_id(herdId) {
     });
     return IWebResponse.success(sortedSessions).to_compatible();
 }
-// Get connectivity by session id using RPC function with coordinates
-export async function server_get_connectivity_by_session_id(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase.rpc("get_connectivity_with_coordinates", { session_id_caller: sessionId });
-    if (error) {
-        console.warn("Error fetching connectivity by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    // Sort by timestamp_start in ascending order
-    const sortedConnectivity = (data || []).sort((a, b) => {
-        if (!a.timestamp_start || !b.timestamp_start)
-            return 0;
-        return (new Date(a.timestamp_start).getTime() -
-            new Date(b.timestamp_start).getTime());
-    });
-    return IWebResponse.success(sortedConnectivity).to_compatible();
-}
 // Get events by session id
 export async function server_get_events_by_session_id(sessionId) {
     const supabase = await newServerClient();

package/dist/helpers/time.d.ts

@@ -1,3 +1,7 @@
 export declare function convertSecondsSinceEpochToDate(secondsSinceEpoch: number): Date;
 export declare function convertIsoStringToDate(isoString: string): Date;
 export declare function convertDateToTimeString(date: Date): string;
+export declare function formatTimestampForDatabase(date: Date): string;
+export declare function getDaysAgoTimestamp(daysAgo: number): string;
+export declare function getHoursAgoTimestamp(hoursAgo: number): string;
+export declare function getMinutesAgoTimestamp(minutesAgo: number): string;

package/dist/helpers/time.js

@@ -9,3 +9,26 @@ export function convertIsoStringToDate(isoString) {
 export function convertDateToTimeString(date) {
     return `${date.toLocaleTimeString()}, ${date.toLocaleDateString()} UTC`;
 }
+// Format a Date object as a PostgreSQL-compatible timestamp string
+// Returns format: "YYYY-MM-DDTHH:MM:SS.SSSZ" (ISO 8601 with timezone)
+export function formatTimestampForDatabase(date) {
+    return date.toISOString();
+}
+// Get a timestamp for N days ago, formatted for database queries
+export function getDaysAgoTimestamp(daysAgo) {
+    const date = new Date();
+    date.setDate(date.getDate() - daysAgo);
+    return formatTimestampForDatabase(date);
+}
+// Get a timestamp for N hours ago, formatted for database queries
+export function getHoursAgoTimestamp(hoursAgo) {
+    const date = new Date();
+    date.setHours(date.getHours() - hoursAgo);
+    return formatTimestampForDatabase(date);
+}
+// Get a timestamp for N minutes ago, formatted for database queries
+export function getMinutesAgoTimestamp(minutesAgo) {
+    const date = new Date();
+    date.setMinutes(date.getMinutes() - minutesAgo);
+    return formatTimestampForDatabase(date);
+}

package/dist/hooks/index.d.ts

@@ -1,2 +1,3 @@
-export { useScoutDbListener } from "./useScoutDbListener";
 export { useScoutRefresh, type UseScoutRefreshOptions, } from "./useScoutRefresh";
+export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
+export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";

package/dist/hooks/index.js

@@ -1,2 +1,3 @@
-export { useScoutDbListener } from "./useScoutDbListener";
 export { useScoutRefresh, } from "./useScoutRefresh";
+export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
+export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";

package/dist/hooks/useScoutRealtimeConnectivity.d.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+export declare function useScoutRealtimeConnectivity(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutRealtimeConnectivity.js

@@ -0,0 +1,157 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { setActiveHerdGpsTrackersConnectivity } from "../store/scout";
+import { server_get_connectivity_by_device_id } from "../helpers/connectivity";
+import { EnumWebResponse } from "../types/requests";
+import { getDaysAgoTimestamp } from "../helpers/time";
+export function useScoutRealtimeConnectivity(scoutSupabase) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [isLoading, setIsLoading] = useState(false);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    const activeHerdGpsTrackersConnectivity = useSelector((state) => state.scout.active_herd_gps_trackers_connectivity);
+    const herdModules = useSelector((state) => state.scout.herd_modules);
+    // Connectivity broadcast handler
+    const handleConnectivityBroadcast = useCallback((payload) => {
+        console.log("[Connectivity] Broadcast received:", payload.payload.event);
+        const event = payload.payload.event;
+        const data = payload.payload;
+        const connectivityData = data.new || data.old;
+        // Only process tracker connectivity data (no session_id)
+        if (!connectivityData || connectivityData.session_id) {
+            return;
+        }
+        const deviceId = connectivityData.device_id;
+        if (!deviceId)
+            return;
+        const currentConnectivity = {
+            ...activeHerdGpsTrackersConnectivity,
+        };
+        console.log("[Connectivity] Current connectivity:", currentConnectivity);
+        switch (event) {
+            case "INSERT":
+                if (!currentConnectivity[deviceId]) {
+                    currentConnectivity[deviceId] = [];
+                }
+                currentConnectivity[deviceId].push(connectivityData);
+                // Keep only recent 100 entries
+                if (currentConnectivity[deviceId].length > 100) {
+                    currentConnectivity[deviceId] = currentConnectivity[deviceId]
+                        .sort((a, b) => new Date(b.timestamp_start || 0).getTime() -
+                        new Date(a.timestamp_start || 0).getTime())
+                        .slice(0, 100);
+                }
+                break;
+            case "UPDATE":
+                if (currentConnectivity[deviceId]) {
+                    const index = currentConnectivity[deviceId].findIndex((c) => c.id === connectivityData.id);
+                    if (index >= 0) {
+                        currentConnectivity[deviceId][index] = connectivityData;
+                    }
+                }
+                break;
+            case "DELETE":
+                if (currentConnectivity[deviceId]) {
+                    currentConnectivity[deviceId] = currentConnectivity[deviceId].filter((c) => c.id !== connectivityData.id);
+                    if (currentConnectivity[deviceId].length === 0) {
+                        delete currentConnectivity[deviceId];
+                    }
+                }
+                break;
+        }
+        dispatch(setActiveHerdGpsTrackersConnectivity(currentConnectivity));
+    }, [activeHerdGpsTrackersConnectivity, dispatch]);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createConnectivityChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-connectivity`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleConnectivityBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Connectivity] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.error(`[Connectivity] ❌ Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    // Fetch initial connectivity data for GPS trackers
+    const fetchInitialConnectivityData = useCallback(async () => {
+        if (!activeHerdId || isLoading)
+            return;
+        // Find the active herd module
+        const activeHerdModule = herdModules.find((hm) => hm.herd.id.toString() === activeHerdId);
+        if (!activeHerdModule)
+            return;
+        // Get GPS tracker devices from the herd
+        const gpsTrackerDevices = activeHerdModule.devices.filter((device) => device.device_type === "gps_tracker" ||
+            device.device_type === "gps_tracker_vehicle" ||
+            device.device_type === "gps_tracker_person");
+        if (gpsTrackerDevices.length === 0) {
+            console.log("[Connectivity] No GPS trackers found in herd");
+            return;
+        }
+        setIsLoading(true);
+        console.log(`[Connectivity] Fetching last day connectivity for ${gpsTrackerDevices.length} GPS trackers`);
+        // Calculate timestamp for last 24 hours
+        const timestampFilter = getDaysAgoTimestamp(1);
+        const connectivityData = {};
+        try {
+            // Fetch connectivity for each GPS tracker
+            await Promise.all(gpsTrackerDevices.map(async (device) => {
+                try {
+                    if (!device.id)
+                        return;
+                    const response = await server_get_connectivity_by_device_id(device.id, timestampFilter);
+                    if (response.status === EnumWebResponse.SUCCESS && response.data) {
+                        // Filter out any data with session_id (only tracker data)
+                        const trackerConnectivity = response.data.filter((conn) => !conn.session_id);
+                        if (trackerConnectivity.length > 0 && device.id) {
+                            // Keep only most recent 100 entries per device
+                            connectivityData[device.id] = trackerConnectivity
+                                .sort((a, b) => new Date(b.timestamp_start || 0).getTime() -
+                                new Date(a.timestamp_start || 0).getTime())
+                                .slice(0, 100);
+                            console.log(`[Connectivity] Loaded ${connectivityData[device.id]?.length} records for device ${device.id}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`[Connectivity] Failed to fetch data for device ${device.id}:`, error);
+                }
+            }));
+            // Update the store with initial connectivity data
+            dispatch(setActiveHerdGpsTrackersConnectivity(connectivityData));
+            console.log(`[Connectivity] Initial data loaded for ${Object.keys(connectivityData).length} devices`);
+        }
+        catch (error) {
+            console.error("[Connectivity] Error fetching initial data:", error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [activeHerdId, herdModules, isLoading, dispatch]);
+    useEffect(() => {
+        if (!scoutSupabase)
+            return;
+        cleanupChannels();
+        // Create connectivity channel for active herd
+        if (activeHerdId) {
+            const channel = createConnectivityChannel(activeHerdId);
+            channels.current.push(channel);
+            // Fetch initial connectivity data
+            fetchInitialConnectivityData();
+        }
+        return cleanupChannels;
+    }, [
+        scoutSupabase,
+        activeHerdId,
+        handleConnectivityBroadcast,
+        fetchInitialConnectivityData,
+    ]);
+}

package/dist/hooks/useScoutRealtimeDevices.d.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+export declare function useScoutRealtimeDevices(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutRealtimeDevices.js

@@ -0,0 +1,58 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback } from "react";
+import { addDevice, deleteDevice, updateDevice } from "../store/scout";
+export function useScoutRealtimeDevices(scoutSupabase) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Device broadcast handler
+    const handleDeviceBroadcast = useCallback((payload) => {
+        console.log("[Devices] Broadcast received:", payload.payload.event);
+        const event = payload.payload.event;
+        const data = payload.payload;
+        switch (event) {
+            case "INSERT":
+                if (data.new)
+                    dispatch(addDevice(data.new));
+                break;
+            case "UPDATE":
+                if (data.new)
+                    dispatch(updateDevice(data.new));
+                break;
+            case "DELETE":
+                if (data.old)
+                    dispatch(deleteDevice(data.old));
+                break;
+        }
+    }, [dispatch]);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createDevicesChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-devices`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleDeviceBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Devices] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.error(`[Devices] ❌ Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        if (!scoutSupabase)
+            return;
+        cleanupChannels();
+        // Create devices channel for active herd
+        if (activeHerdId) {
+            const channel = createDevicesChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [scoutSupabase, activeHerdId, handleDeviceBroadcast]);
+}

package/dist/index.d.ts

@@ -9,9 +9,11 @@ export * from "./types/gps";
 export * from "./types/supabase";
 export * from "./types/bounding_boxes";
 export * from "./types/events";
+export * from "./types/connectivity";
 export * from "./helpers/auth";
 export * from "./helpers/bounding_boxes";
 export * from "./helpers/chat";
+export * from "./helpers/connectivity";
 export * from "./helpers/db";
 export * from "./helpers/devices";
 export * from "./helpers/email";
@@ -33,7 +35,8 @@ export * from "./helpers/eventUtils";
 export * from "./helpers/cache";
 export * from "./helpers/heartbeats";
 export * from "./helpers/providers";
-export * from "./hooks/useScoutDbListener";
+export * from "./hooks/useScoutRealtimeConnectivity";
+export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";
 export * from "./store/scout";

package/dist/index.js

@@ -11,10 +11,12 @@ export * from "./types/gps";
 export * from "./types/supabase";
 export * from "./types/bounding_boxes";
 export * from "./types/events";
+export * from "./types/connectivity";
 // Helpers
 export * from "./helpers/auth";
 export * from "./helpers/bounding_boxes";
 export * from "./helpers/chat";
+export * from "./helpers/connectivity";
 export * from "./helpers/db";
 export * from "./helpers/devices";
 export * from "./helpers/email";
@@ -37,7 +39,8 @@ export * from "./helpers/cache";
 export * from "./helpers/heartbeats";
 export * from "./helpers/providers";
 // Hooks
-export * from "./hooks/useScoutDbListener";
+export * from "./hooks/useScoutRealtimeConnectivity";
+export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRefresh";
 // Providers
 export * from "./providers";