@adventurelabs/scout-core 1.0.53 → 1.0.55

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/layers.d.ts

@@ -0,0 +1,3 @@
+import { ILayer } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_layers_by_herd(herd_id: number): Promise<IWebResponseCompatible<ILayer[]>>;

package/dist/helpers/layers.js

@@ -0,0 +1,21 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+// function that fetches the layers from our db given a herd id
+export async function server_get_layers_by_herd(herd_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("layers")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).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,127 @@
 "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);
-    // 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);
-                }
-            }
-        });
-        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 () => {
-        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);
-            }
-            catch (error) {
-                console.error(`[DB Listener] Failed to set up ${tableName} channel:`, error);
-            }
-        }
-        return successCount > 0;
-    };
-    // Initialize connection
-    const initializeConnection = async () => {
-        if (!scoutSupabase)
+    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;
-        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");
-            }
-            // Set up channels
-            const success = await setupChannels();
-            if (!success) {
-                throw new Error("Channel setup failed");
-            }
         }
-        catch (error) {
-            setLastError(error instanceof Error ? error.message : "Unknown error");
-            setConnectionState(ConnectionState.ERROR);
+        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;
         }
-    };
-    // Main effect
+        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);
+    }
     useEffect(() => {
         if (!scoutSupabase) {
-            setConnectionState(ConnectionState.ERROR);
-            setLastError("No Supabase client available");
+            console.error("[DB Listener] No Supabase client available");
             return;
         }
-        initializeConnection();
+        supabase.current = scoutSupabase;
+        // Create a single channel for all operations
+        const channelName = `scout_realtime_${Date.now()}`;
+        const mainChannel = scoutSupabase.channel(channelName);
+        // 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");
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.error("[DB Listener] ❌ Channel error occurred");
+            }
+            else if (status === "TIMED_OUT") {
+                console.error("[DB Listener] ⏰ Subscription timed out");
+            }
+            else if (status === "CLOSED") {
+                console.log("[DB Listener] 🔒 Channel closed");
+            }
+        });
+        channels.current.push(mainChannel);
+        // Cleanup function
         return () => {
-            cleanupChannels();
+            console.log("[DB Listener] 🧹 Cleaning up channels");
+            channels.current.forEach((channel) => {
+                if (channel) {
+                    scoutSupabase.removeChannel(channel);
+                }
+            });
+            channels.current = [];
         };
-    }, [scoutSupabase]);
-    return {
-        connectionState,
-        lastError,
-        isConnected: connectionState === ConnectionState.CONNECTED,
-        isConnecting: connectionState === ConnectionState.CONNECTING,
-    };
+    }, [scoutSupabase, dispatch]);
 }

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export * from "./helpers/gps";
 export * from "./helpers/herds";
 export * from "./helpers/location";
 export * from "./helpers/plans";
+export * from "./helpers/layers";
 export * from "./helpers/sessions";
 export * from "./helpers/tags";
 export * from "./helpers/time";
@@ -36,7 +37,6 @@ export * from "./store/hooks";
 export * from "./supabase/middleware";
 export * from "./supabase/server";
 export * from "./api_keys/actions";
-export type { Database } from "./types/supabase";
 export type { HerdModule, IHerdModule } from "./types/herd_module";
-export type { IDevice, IEvent, IUser, IHerd, IEventWithTags, IZoneWithActions, IUserAndRole, IApiKeyScout, } from "./types/db";
+export type { IDevice, IEvent, IUser, IHerd, IEventWithTags, IZoneWithActions, IUserAndRole, IApiKeyScout, ILayer, } from "./types/db";
 export { EnumSessionsVisibility } from "./types/events";

package/dist/index.js

@@ -22,6 +22,7 @@ export * from "./helpers/gps";
 export * from "./helpers/herds";
 export * from "./helpers/location";
 export * from "./helpers/plans";
+export * from "./helpers/layers";
 export * from "./helpers/sessions";
 export * from "./helpers/tags";
 export * from "./helpers/time";