@adventurelabs/scout-core 1.0.74 → 1.0.77

package/dist/helpers/chat.d.ts

@@ -1,11 +1,10 @@
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
 import { TablesInsert } from "../types/supabase";
 export type ChatMessageInsert = TablesInsert<"chat">;
-export declare function insert_chat_message(supabaseClient: SupabaseClient, message: string, herd_id: number, sender?: string): Promise<IWebResponseCompatible<{
+export declare function server_insert_chat_message(message: string, herd_id: number, sender?: string): Promise<IWebResponseCompatible<{
     id: number;
 }>>;
-export declare function get_chat_messages(supabaseClient: SupabaseClient, limit: number | undefined, offset: number | undefined, herd_id: number): Promise<IWebResponseCompatible<Array<{
+export declare function server_get_chat_messages(limit: number | undefined, offset: number | undefined, herd_id: number): Promise<IWebResponseCompatible<Array<{
     id: number;
     message: string;
     sender: string | null;

package/dist/helpers/chat.js

@@ -1,29 +1,43 @@
-import { IWebResponse } from "../types/requests";
-export async function insert_chat_message(supabaseClient, message, herd_id, sender) {
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse, EnumWebResponse } from "../types/requests";
+export async function server_insert_chat_message(message, herd_id, sender) {
+    const supabase = await newServerClient();
     const chatMessage = {
         message,
         herd_id,
         sender: sender || null,
     };
-    const { data, error } = await supabaseClient
+    const { data, error } = await supabase
         .from("chat")
         .insert(chatMessage)
         .select("id")
         .single();
     if (error) {
-        return IWebResponse.error(`Failed to insert chat message: ${error.message}`).to_compatible();
+        console.warn("Error inserting chat message:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: `Failed to insert chat message: ${error.message}`,
+            data: null,
+        };
     }
     return IWebResponse.success({ id: data.id }).to_compatible();
 }
-export async function get_chat_messages(supabaseClient, limit = 50, offset = 0, herd_id) {
-    const { data, error } = await supabaseClient
+export async function server_get_chat_messages(limit = 50, offset = 0, herd_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
         .from("chat")
         .select("id, message, sender, created_at")
         .order("created_at", { ascending: false })
         .range(offset, offset + limit - 1)
         .eq("herd_id", herd_id);
     if (error) {
-        return IWebResponse.error(`Failed to fetch chat messages: ${error.message}`).to_compatible();
+        console.warn("Error fetching chat messages:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: `Failed to fetch chat messages: ${error.message}`,
+            data: [],
+        };
     }
     return IWebResponse.success(data || []).to_compatible();
 }

package/dist/helpers/sessions.d.ts

@@ -1,6 +1,5 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-import { ISession, IConnectivity, IEvent, ISessionWithCoordinates, IConnectivityWithCoordinates, IEventAndTagsPrettyLocation, ScoutDatabaseClient } from "../types/db";
+import { ISession, IConnectivity, IEvent, ISessionWithCoordinates, IConnectivityWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
 export type SessionInput = Omit<ISession, "id" | "inserted_at">;
 export type SessionUpdateInput = Partial<SessionInput> & {
     id: number;
@@ -11,28 +10,28 @@ export type ConnectivityUpdateInput = Partial<ConnectivityInput> & {
     id: number;
 };
 export type ConnectivityUpsertInput = ConnectivityInput | ConnectivityUpdateInput;
-export declare function getSessionsByHerdId(supabase: SupabaseClient<Database, "public">, herdId: number): Promise<ISessionWithCoordinates[]>;
-export declare function getConnectivityBySessionId(supabase: SupabaseClient<Database, "public">, sessionId: number): Promise<IConnectivityWithCoordinates[]>;
-export declare function getEventsBySessionId(supabase: SupabaseClient<Database, "public">, sessionId: number): Promise<IEvent[]>;
-export declare function getEventsAndTagsBySessionId(supabase: SupabaseClient<Database, "public">, sessionId: number, limit?: number, offset?: number): Promise<IEventAndTagsPrettyLocation[]>;
-export declare function getTotalEventsForSession(supabase: SupabaseClient<Database, "public">, sessionId: number): Promise<number>;
-export declare function upsertSession(supabase: SupabaseClient<Database, "public">, sessionData: SessionUpsertInput): Promise<ISession>;
-export declare function upsertSessions(supabase: SupabaseClient<Database, "public">, sessionsData: SessionUpsertInput[]): Promise<ISession[]>;
-export declare function upsertConnectivity(supabase: SupabaseClient<Database, "public">, connectivityData: ConnectivityUpsertInput): Promise<IConnectivity>;
-export declare function upsertConnectivityBatch(supabase: SupabaseClient<Database, "public">, connectivityDataArray: ConnectivityUpsertInput[]): Promise<IConnectivity[]>;
-export declare function getSessionWithConnectivityAndEvents(supabase: ScoutDatabaseClient, sessionId: number, herdId?: number): Promise<{
+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>>;
+export declare function server_upsert_session(sessionData: SessionUpsertInput): Promise<IWebResponseCompatible<ISession>>;
+export declare function server_upsert_sessions(sessionsData: SessionUpsertInput[]): Promise<IWebResponseCompatible<ISession[]>>;
+export declare function server_upsert_connectivity(connectivityData: ConnectivityUpsertInput): Promise<IWebResponseCompatible<IConnectivity>>;
+export declare function server_upsert_connectivity_batch(connectivityDataArray: ConnectivityUpsertInput[]): Promise<IWebResponseCompatible<IConnectivity[]>>;
+export declare function server_get_session_with_connectivity_and_events(sessionId: number, herdId?: number): Promise<IWebResponseCompatible<{
     session: ISessionWithCoordinates | null;
     connectivity: IConnectivityWithCoordinates[];
     events: IEvent[];
-}>;
-export declare function getSessionWithConnectivityAndEventsWithTags(supabase: ScoutDatabaseClient, sessionId: number, limit?: number, offset?: number, herdId?: number): Promise<{
+}>>;
+export declare function server_get_session_with_connectivity_and_events_with_tags(sessionId: number, limit?: number, offset?: number, herdId?: number): Promise<IWebResponseCompatible<{
     session: ISessionWithCoordinates | null;
     connectivity: IConnectivityWithCoordinates[];
     eventsWithTags: IEventAndTagsPrettyLocation[];
     totalEvents: number;
-}>;
-export declare function getSessionsByDeviceId(supabase: ScoutDatabaseClient, deviceId: number): Promise<ISessionWithCoordinates[]>;
-export declare function deleteSession(supabase: ScoutDatabaseClient, sessionId: number): Promise<void>;
-export declare function deleteSessions(supabase: ScoutDatabaseClient, sessionIds: number[]): Promise<void>;
-export declare function deleteConnectivity(supabase: ScoutDatabaseClient, connectivityId: number): Promise<void>;
-export declare function deleteConnectivityBatch(supabase: ScoutDatabaseClient, connectivityIds: number[]): Promise<void>;
+}>>;
+export declare function server_get_sessions_by_device_id(deviceId: number): Promise<IWebResponseCompatible<ISessionWithCoordinates[]>>;
+export declare function server_delete_session(sessionId: number): Promise<IWebResponseCompatible<boolean>>;
+export declare function server_delete_sessions(sessionIds: number[]): Promise<IWebResponseCompatible<boolean>>;
+export declare function server_delete_connectivity(connectivityId: number): Promise<IWebResponseCompatible<boolean>>;
+export declare function server_delete_connectivity_batch(connectivityIds: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/sessions.js

@@ -1,10 +1,19 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
 // Get sessions by herd id using RPC function with coordinates
-export async function getSessionsByHerdId(supabase, herdId) {
+export async function server_get_sessions_by_herd_id(herdId) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("get_sessions_with_coordinates", {
         herd_id_caller: herdId,
     });
     if (error) {
-        throw new Error(`Failed to get sessions by herd id: ${error.message}`);
+        console.warn("Error fetching sessions by herd id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
     }
     // Sort by timestamp_start in descending order
     const sortedSessions = (data || []).sort((a, b) => {
@@ -13,13 +22,19 @@ export async function getSessionsByHerdId(supabase, herdId) {
         return (new Date(b.timestamp_start).getTime() -
             new Date(a.timestamp_start).getTime());
     });
-    return sortedSessions;
+    return IWebResponse.success(sortedSessions).to_compatible();
 }
 // Get connectivity by session id using RPC function with coordinates
-export async function getConnectivityBySessionId(supabase, sessionId) {
+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) {
-        throw new Error(`Failed to get connectivity by session id: ${error.message}`);
+        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) => {
@@ -28,44 +43,63 @@ export async function getConnectivityBySessionId(supabase, sessionId) {
         return (new Date(a.timestamp_start).getTime() -
             new Date(b.timestamp_start).getTime());
     });
-    return sortedConnectivity;
+    return IWebResponse.success(sortedConnectivity).to_compatible();
 }
 // Get events by session id
-export async function getEventsBySessionId(supabase, sessionId) {
+export async function server_get_events_by_session_id(sessionId) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase
         .from("events")
         .select("*")
         .eq("session_id", sessionId)
         .order("timestamp_observation", { ascending: true });
     if (error) {
-        throw new Error(`Failed to get events by session id: ${error.message}`);
+        console.warn("Error fetching events by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
     }
-    return data || [];
+    return IWebResponse.success(data || []).to_compatible();
 }
 // Get events with tags by session id using RPC function
-export async function getEventsAndTagsBySessionId(supabase, sessionId, limit = 50, offset = 0) {
+export async function server_get_events_and_tags_by_session_id(sessionId, limit = 50, offset = 0) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("get_events_and_tags_for_session", {
         session_id_caller: sessionId,
         limit_caller: limit,
         offset_caller: offset,
     });
     if (error) {
-        throw new Error(`Failed to get events and tags by session id: ${error.message}`);
+        console.warn("Error fetching events and tags by session id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
     }
-    return data || [];
+    return IWebResponse.success(data || []).to_compatible();
 }
 // Get total count of events for a session
-export async function getTotalEventsForSession(supabase, sessionId) {
+export async function server_get_total_events_for_session(sessionId) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("get_total_events_for_session", {
         session_id_caller: sessionId,
     });
     if (error) {
-        throw new Error(`Failed to get total events for session: ${error.message}`);
+        console.warn("Error fetching total events for session:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: 0,
+        };
     }
-    return data || 0;
+    return IWebResponse.success(data || 0).to_compatible();
 }
 // Create or update session
-export async function upsertSession(supabase, sessionData) {
+export async function server_upsert_session(sessionData) {
+    const supabase = await newServerClient();
     const isUpdate = "id" in sessionData;
     if (isUpdate) {
         // Update existing session
@@ -77,9 +111,14 @@ export async function upsertSession(supabase, sessionData) {
             .select()
             .single();
         if (error) {
-            throw new Error(`Failed to update session: ${error.message}`);
+            console.warn("Error updating session:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: null,
+            };
         }
-        return data;
+        return IWebResponse.success(data).to_compatible();
     }
     else {
         // Create new session
@@ -89,15 +128,21 @@ export async function upsertSession(supabase, sessionData) {
             .select()
             .single();
         if (error) {
-            throw new Error(`Failed to create session: ${error.message}`);
+            console.warn("Error creating session:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: null,
+            };
         }
-        return data;
+        return IWebResponse.success(data).to_compatible();
     }
 }
 // Batch upsert sessions
-export async function upsertSessions(supabase, sessionsData) {
+export async function server_upsert_sessions(sessionsData) {
+    const supabase = await newServerClient();
     if (sessionsData.length === 0) {
-        return [];
+        return IWebResponse.success([]).to_compatible();
     }
     // Separate updates and inserts
     const updates = sessionsData.filter((s) => "id" in s);
@@ -106,12 +151,12 @@ export async function upsertSessions(supabase, sessionsData) {
     // Handle updates
     if (updates.length > 0) {
         for (const sessionData of updates) {
-            try {
-                const result = await upsertSession(supabase, sessionData);
-                results.push(result);
+            const updateResult = await server_upsert_session(sessionData);
+            if (updateResult.status === EnumWebResponse.SUCCESS && updateResult.data) {
+                results.push(updateResult.data);
             }
-            catch (error) {
-                throw new Error(`Failed to update session ${sessionData.id}: ${error}`);
+            else {
+                console.warn(`Failed to update session ${sessionData.id}:`, updateResult.msg);
             }
         }
     }
@@ -122,14 +167,20 @@ export async function upsertSessions(supabase, sessionsData) {
             .insert(inserts)
             .select();
         if (error) {
-            throw new Error(`Failed to create sessions: ${error.message}`);
+            console.warn("Error creating sessions:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: results,
+            };
         }
         results.push(...(data || []));
     }
-    return results;
+    return IWebResponse.success(results).to_compatible();
 }
 // Create or update connectivity
-export async function upsertConnectivity(supabase, connectivityData) {
+export async function server_upsert_connectivity(connectivityData) {
+    const supabase = await newServerClient();
     const isUpdate = "id" in connectivityData;
     if (isUpdate) {
         // Update existing connectivity
@@ -141,9 +192,14 @@ export async function upsertConnectivity(supabase, connectivityData) {
             .select()
             .single();
         if (error) {
-            throw new Error(`Failed to update connectivity: ${error.message}`);
+            console.warn("Error updating connectivity:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: null,
+            };
         }
-        return data;
+        return IWebResponse.success(data).to_compatible();
     }
     else {
         // Create new connectivity
@@ -153,15 +209,21 @@ export async function upsertConnectivity(supabase, connectivityData) {
             .select()
             .single();
         if (error) {
-            throw new Error(`Failed to create connectivity: ${error.message}`);
+            console.warn("Error creating connectivity:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: null,
+            };
         }
-        return data;
+        return IWebResponse.success(data).to_compatible();
     }
 }
 // Batch upsert connectivity
-export async function upsertConnectivityBatch(supabase, connectivityDataArray) {
+export async function server_upsert_connectivity_batch(connectivityDataArray) {
+    const supabase = await newServerClient();
     if (connectivityDataArray.length === 0) {
-        return [];
+        return IWebResponse.success([]).to_compatible();
     }
     // Separate updates and inserts
     const updates = connectivityDataArray.filter((c) => "id" in c);
@@ -170,12 +232,12 @@ export async function upsertConnectivityBatch(supabase, connectivityDataArray) {
     // Handle updates
     if (updates.length > 0) {
         for (const connectivityData of updates) {
-            try {
-                const result = await upsertConnectivity(supabase, connectivityData);
-                results.push(result);
+            const updateResult = await server_upsert_connectivity(connectivityData);
+            if (updateResult.status === EnumWebResponse.SUCCESS && updateResult.data) {
+                results.push(updateResult.data);
             }
-            catch (error) {
-                throw new Error(`Failed to update connectivity ${connectivityData.id}: ${error}`);
+            else {
+                console.warn(`Failed to update connectivity ${connectivityData.id}:`, updateResult.msg);
             }
         }
     }
@@ -186,27 +248,27 @@ export async function upsertConnectivityBatch(supabase, connectivityDataArray) {
             .insert(inserts)
             .select();
         if (error) {
-            throw new Error(`Failed to create connectivity entries: ${error.message}`);
+            console.warn("Error creating connectivity entries:", error.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: error.message,
+                data: results,
+            };
         }
         results.push(...(data || []));
     }
-    return results;
+    return IWebResponse.success(results).to_compatible();
 }
 // Get session with connectivity and events using RPC functions
-export async function getSessionWithConnectivityAndEvents(supabase, sessionId, herdId) {
+export async function server_get_session_with_connectivity_and_events(sessionId, herdId) {
+    const supabase = await newServerClient();
     let sessionWithCoords = null;
     if (herdId) {
         // Use provided herd ID directly
-        // Get sessions with coordinates for the herd and find our specific session
-        const { data: allSessionsWithCoords, error: sessionsError } = await supabase.rpc("get_sessions_with_coordinates", {
-            herd_id_caller: herdId,
-        });
-        if (sessionsError) {
-            throw new Error(`Failed to get session with coordinates: ${sessionsError.message}`);
+        const sessionsResult = await server_get_sessions_by_herd_id(herdId);
+        if (sessionsResult.status === EnumWebResponse.SUCCESS && sessionsResult.data) {
+            sessionWithCoords = sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
-        // Find the specific session in the results
-        sessionWithCoords =
-            allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     }
     else {
         // Get the session from the sessions table first to get the device_id
@@ -216,7 +278,16 @@ export async function getSessionWithConnectivityAndEvents(supabase, sessionId, h
             .eq("id", sessionId)
             .single();
         if (sessionError) {
-            throw new Error(`Failed to get session: ${sessionError.message}`);
+            console.warn("Error getting session:", sessionError.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: sessionError.message,
+                data: {
+                    session: null,
+                    connectivity: [],
+                    events: [],
+                },
+            };
         }
         // Get the device to find its herd_id
         const { data: device, error: deviceError } = await supabase
@@ -225,46 +296,46 @@ export async function getSessionWithConnectivityAndEvents(supabase, sessionId, h
             .eq("id", sessionData.device_id)
             .single();
         if (deviceError) {
-            throw new Error(`Failed to get device: ${deviceError.message}`);
+            console.warn("Error getting device:", deviceError.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: deviceError.message,
+                data: {
+                    session: null,
+                    connectivity: [],
+                    events: [],
+                },
+            };
         }
-        // Get sessions with coordinates for the herd and find our specific session
-        const { data: allSessionsWithCoords, error: sessionsError } = await supabase.rpc("get_sessions_with_coordinates", {
-            herd_id_caller: device.herd_id,
-        });
-        if (sessionsError) {
-            throw new Error(`Failed to get session with coordinates: ${sessionsError.message}`);
+        const sessionsResult = await server_get_sessions_by_herd_id(device.herd_id);
+        if (sessionsResult.status === EnumWebResponse.SUCCESS && sessionsResult.data) {
+            sessionWithCoords = sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
-        // Find the specific session in the results
-        sessionWithCoords =
-            allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     }
     const [connectivityResult, eventsResult] = await Promise.all([
-        getConnectivityBySessionId(supabase, sessionId),
-        getEventsBySessionId(supabase, sessionId),
+        server_get_connectivity_by_session_id(sessionId),
+        server_get_events_by_session_id(sessionId),
     ]);
-    return {
+    const connectivity = connectivityResult.status === EnumWebResponse.SUCCESS ? connectivityResult.data || [] : [];
+    const events = eventsResult.status === EnumWebResponse.SUCCESS ? eventsResult.data || [] : [];
+    return IWebResponse.success({
         session: sessionWithCoords,
-        connectivity: connectivityResult,
-        events: eventsResult,
-    };
+        connectivity,
+        events,
+    }).to_compatible();
 }
 // Get session with connectivity and events with tags using RPC functions
-export async function getSessionWithConnectivityAndEventsWithTags(supabase, sessionId, limit = 50, offset = 0, herdId) {
+export async function server_get_session_with_connectivity_and_events_with_tags(sessionId, limit = 50, offset = 0, herdId) {
+    const supabase = await newServerClient();
     let sessionWithCoords = null;
     let actualHerdId;
     if (herdId) {
         // Use provided herd ID directly
         actualHerdId = herdId;
-        // Get sessions with coordinates for the herd and find our specific session
-        const { data: allSessionsWithCoords, error: sessionsError } = await supabase.rpc("get_sessions_with_coordinates", {
-            herd_id_caller: actualHerdId,
-        });
-        if (sessionsError) {
-            throw new Error(`Failed to get session with coordinates: ${sessionsError.message}`);
+        const sessionsResult = await server_get_sessions_by_herd_id(herdId);
+        if (sessionsResult.status === EnumWebResponse.SUCCESS && sessionsResult.data) {
+            sessionWithCoords = sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
-        // Find the specific session in the results
-        sessionWithCoords =
-            allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     }
     else {
         // Get the session from the sessions table first to get the device_id
@@ -274,7 +345,17 @@ export async function getSessionWithConnectivityAndEventsWithTags(supabase, sess
             .eq("id", sessionId)
             .single();
         if (sessionError) {
-            throw new Error(`Failed to get session: ${sessionError.message}`);
+            console.warn("Error getting session:", sessionError.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: sessionError.message,
+                data: {
+                    session: null,
+                    connectivity: [],
+                    eventsWithTags: [],
+                    totalEvents: 0,
+                },
+            };
         }
         // Get the device to find its herd_id
         const { data: device, error: deviceError } = await supabase
@@ -283,85 +364,126 @@ export async function getSessionWithConnectivityAndEventsWithTags(supabase, sess
             .eq("id", sessionData.device_id)
             .single();
         if (deviceError) {
-            throw new Error(`Failed to get device: ${deviceError.message}`);
+            console.warn("Error getting device:", deviceError.message);
+            return {
+                status: EnumWebResponse.ERROR,
+                msg: deviceError.message,
+                data: {
+                    session: null,
+                    connectivity: [],
+                    eventsWithTags: [],
+                    totalEvents: 0,
+                },
+            };
         }
         actualHerdId = device.herd_id;
-        // Get sessions with coordinates for the herd and find our specific session
-        const { data: allSessionsWithCoords, error: sessionsError } = await supabase.rpc("get_sessions_with_coordinates", {
-            herd_id_caller: actualHerdId,
-        });
-        if (sessionsError) {
-            throw new Error(`Failed to get session with coordinates: ${sessionsError.message}`);
+        const sessionsResult = await server_get_sessions_by_herd_id(device.herd_id);
+        if (sessionsResult.status === EnumWebResponse.SUCCESS && sessionsResult.data) {
+            sessionWithCoords = sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
-        // Find the specific session in the results
-        sessionWithCoords =
-            allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     }
     const [connectivityResult, eventsWithTagsResult, totalEventsResult] = await Promise.all([
-        getConnectivityBySessionId(supabase, sessionId),
-        getEventsAndTagsBySessionId(supabase, sessionId, limit, offset),
-        getTotalEventsForSession(supabase, sessionId),
+        server_get_connectivity_by_session_id(sessionId),
+        server_get_events_and_tags_by_session_id(sessionId, limit, offset),
+        server_get_total_events_for_session(sessionId),
     ]);
-    return {
+    const connectivity = connectivityResult.status === EnumWebResponse.SUCCESS ? connectivityResult.data || [] : [];
+    const eventsWithTags = eventsWithTagsResult.status === EnumWebResponse.SUCCESS ? eventsWithTagsResult.data || [] : [];
+    const totalEvents = totalEventsResult.status === EnumWebResponse.SUCCESS ? totalEventsResult.data || 0 : 0;
+    return IWebResponse.success({
         session: sessionWithCoords,
-        connectivity: connectivityResult,
-        eventsWithTags: eventsWithTagsResult,
-        totalEvents: totalEventsResult,
-    };
+        connectivity,
+        eventsWithTags,
+        totalEvents,
+    }).to_compatible();
 }
 // Get sessions for a device using RPC function
-export async function getSessionsByDeviceId(supabase, deviceId) {
+export async function server_get_sessions_by_device_id(deviceId) {
+    const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("get_sessions_with_coordinates_by_device", {
         device_id_caller: deviceId,
     });
     if (error) {
-        throw new Error(`Failed to get sessions by device id: ${error.message}`);
+        console.warn("Error fetching sessions by device id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
     }
-    return data || [];
+    return IWebResponse.success(data || []).to_compatible();
 }
 // Delete session and all related data
-export async function deleteSession(supabase, sessionId) {
+export async function server_delete_session(sessionId) {
+    const supabase = await newServerClient();
     const { error } = await supabase
         .from("sessions")
         .delete()
         .eq("id", sessionId);
     if (error) {
-        throw new Error(`Failed to delete session: ${error.message}`);
+        console.warn("Error deleting session:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
     }
+    return IWebResponse.success(true).to_compatible();
 }
 // Batch delete sessions
-export async function deleteSessions(supabase, sessionIds) {
+export async function server_delete_sessions(sessionIds) {
+    const supabase = await newServerClient();
     if (sessionIds.length === 0) {
-        return;
+        return IWebResponse.success(true).to_compatible();
     }
     const { error } = await supabase
         .from("sessions")
         .delete()
         .in("id", sessionIds);
     if (error) {
-        throw new Error(`Failed to delete sessions: ${error.message}`);
+        console.warn("Error deleting sessions:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
     }
+    return IWebResponse.success(true).to_compatible();
 }
 // Delete connectivity entry
-export async function deleteConnectivity(supabase, connectivityId) {
+export async function server_delete_connectivity(connectivityId) {
+    const supabase = await newServerClient();
     const { error } = await supabase
         .from("connectivity")
         .delete()
         .eq("id", connectivityId);
     if (error) {
-        throw new Error(`Failed to delete connectivity: ${error.message}`);
+        console.warn("Error deleting connectivity:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
     }
+    return IWebResponse.success(true).to_compatible();
 }
 // Batch delete connectivity entries
-export async function deleteConnectivityBatch(supabase, connectivityIds) {
+export async function server_delete_connectivity_batch(connectivityIds) {
+    const supabase = await newServerClient();
     if (connectivityIds.length === 0) {
-        return;
+        return IWebResponse.success(true).to_compatible();
     }
     const { error } = await supabase
         .from("connectivity")
         .delete()
         .in("id", connectivityIds);
     if (error) {
-        throw new Error(`Failed to delete connectivity entries: ${error.message}`);
+        console.warn("Error deleting connectivity entries:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
     }
+    return IWebResponse.success(true).to_compatible();
 }

package/dist/types/herd_module.js

@@ -9,7 +9,7 @@ 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_batch } from "../api_keys/actions";
-import { getSessionsByHerdId } from "../helpers/sessions";
+import { server_get_sessions_by_herd_id } from "../helpers/sessions";
 export var EnumHerdModulesLoadingState;
 (function (EnumHerdModulesLoadingState) {
     EnumHerdModulesLoadingState["NOT_LOADING"] = "NOT_LOADING";
@@ -112,9 +112,9 @@ export class HerdModule {
                     console.warn(`[HerdModule] Failed to get plans:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
-                getSessionsByHerdId(client, herd.id).catch((error) => {
+                server_get_sessions_by_herd_id(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get sessions:`, error);
-                    return [];
+                    return { status: EnumWebResponse.ERROR, data: [], msg: error.message };
                 }),
                 server_get_layers_by_herd(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get layers:`, error);
@@ -148,7 +148,7 @@ export class HerdModule {
             const plans = res_plans.status === "fulfilled" && res_plans.value?.data
                 ? res_plans.value.data
                 : [];
-            const sessions = res_sessions.status === "fulfilled" ? res_sessions.value : [];
+            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data ? res_sessions.value.data : [];
             const layers = res_layers.status === "fulfilled" && res_layers.value?.data
                 ? res_layers.value.data
                 : [];

package/package.json

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