@adventurelabs/scout-core 1.0.32 → 1.0.33

package/dist/helpers/sessions.d.ts

@@ -1,6 +1,6 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-import { ISession, IConnectivity, IEvent, ISessionWithCoordinates, IConnectivityWithCoordinates } from "../types/db";
+import { ISession, IConnectivity, IEvent, ISessionWithCoordinates, IConnectivityWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
 export type SessionInput = Omit<ISession, "id" | "inserted_at">;
 export type SessionUpdateInput = Partial<SessionInput> & {
     id: number;
@@ -14,15 +14,23 @@ export type ConnectivityUpsertInput = ConnectivityInput | ConnectivityUpdateInpu
 export declare function getSessionsByHerdId(supabase: SupabaseClient<Database>, herdId: number): Promise<ISessionWithCoordinates[]>;
 export declare function getConnectivityBySessionId(supabase: SupabaseClient<Database>, sessionId: number): Promise<IConnectivityWithCoordinates[]>;
 export declare function getEventsBySessionId(supabase: SupabaseClient<Database>, sessionId: number): Promise<IEvent[]>;
+export declare function getEventsAndTagsBySessionId(supabase: SupabaseClient<Database>, sessionId: number, limit?: number, offset?: number): Promise<IEventAndTagsPrettyLocation[]>;
+export declare function getTotalEventsForSession(supabase: SupabaseClient<Database>, sessionId: number): Promise<number>;
 export declare function upsertSession(supabase: SupabaseClient<Database>, sessionData: SessionUpsertInput): Promise<ISession>;
 export declare function upsertSessions(supabase: SupabaseClient<Database>, sessionsData: SessionUpsertInput[]): Promise<ISession[]>;
 export declare function upsertConnectivity(supabase: SupabaseClient<Database>, connectivityData: ConnectivityUpsertInput): Promise<IConnectivity>;
 export declare function upsertConnectivityBatch(supabase: SupabaseClient<Database>, connectivityDataArray: ConnectivityUpsertInput[]): Promise<IConnectivity[]>;
-export declare function getSessionWithConnectivityAndEvents(supabase: SupabaseClient<Database>, sessionId: number): Promise<{
+export declare function getSessionWithConnectivityAndEvents(supabase: SupabaseClient<Database>, sessionId: number, herdId?: number): Promise<{
     session: ISessionWithCoordinates | null;
     connectivity: IConnectivityWithCoordinates[];
     events: IEvent[];
 }>;
+export declare function getSessionWithConnectivityAndEventsWithTags(supabase: SupabaseClient<Database>, sessionId: number, limit?: number, offset?: number, herdId?: number): Promise<{
+    session: ISessionWithCoordinates | null;
+    connectivity: IConnectivityWithCoordinates[];
+    eventsWithTags: IEventAndTagsPrettyLocation[];
+    totalEvents: number;
+}>;
 export declare function getSessionsByDeviceId(supabase: SupabaseClient<Database>, deviceId: number): Promise<ISessionWithCoordinates[]>;
 export declare function deleteSession(supabase: SupabaseClient<Database>, sessionId: number): Promise<void>;
 export declare function deleteSessions(supabase: SupabaseClient<Database>, sessionIds: number[]): Promise<void>;

package/dist/helpers/sessions.js

@@ -42,6 +42,28 @@ export async function getEventsBySessionId(supabase, sessionId) {
     }
     return data || [];
 }
+// Get events with tags by session id using RPC function
+export async function getEventsAndTagsBySessionId(supabase, sessionId, limit = 50, offset = 0) {
+    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}`);
+    }
+    return data || [];
+}
+// Get total count of events for a session
+export async function getTotalEventsForSession(supabase, sessionId) {
+    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}`);
+    }
+    return data || 0;
+}
 // Create or update session
 export async function upsertSession(supabase, sessionData) {
     const isUpdate = "id" in sessionData;
@@ -171,34 +193,51 @@ export async function upsertConnectivityBatch(supabase, connectivityDataArray) {
     return results;
 }
 // Get session with connectivity and events using RPC functions
-export async function getSessionWithConnectivityAndEvents(supabase, sessionId) {
-    // Get the session from the sessions table first to get the device_id
-    const { data: sessionData, error: sessionError } = await supabase
-        .from("sessions")
-        .select("*")
-        .eq("id", sessionId)
-        .single();
-    if (sessionError) {
-        throw new Error(`Failed to get session: ${sessionError.message}`);
-    }
-    // Get the device to find its herd_id
-    const { data: device, error: deviceError } = await supabase
-        .from("devices")
-        .select("herd_id")
-        .eq("id", sessionData.device_id)
-        .single();
-    if (deviceError) {
-        throw new Error(`Failed to get device: ${deviceError.message}`);
+export async function getSessionWithConnectivityAndEvents(supabase, sessionId, herdId) {
+    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}`);
+        }
+        // Find the specific session in the results
+        sessionWithCoords =
+            allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     }
-    // 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}`);
+    else {
+        // Get the session from the sessions table first to get the device_id
+        const { data: sessionData, error: sessionError } = await supabase
+            .from("sessions")
+            .select("*")
+            .eq("id", sessionId)
+            .single();
+        if (sessionError) {
+            throw new Error(`Failed to get session: ${sessionError.message}`);
+        }
+        // Get the device to find its herd_id
+        const { data: device, error: deviceError } = await supabase
+            .from("devices")
+            .select("herd_id")
+            .eq("id", sessionData.device_id)
+            .single();
+        if (deviceError) {
+            throw new Error(`Failed to get device: ${deviceError.message}`);
+        }
+        // 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}`);
+        }
+        // Find the specific session in the results
+        sessionWithCoords =
+            allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     }
-    // Find the specific session in the results
-    const sessionWithCoords = allSessionsWithCoords?.find((s) => s.id === sessionId) || null;
     const [connectivityResult, eventsResult] = await Promise.all([
         getConnectivityBySessionId(supabase, sessionId),
         getEventsBySessionId(supabase, sessionId),
@@ -209,6 +248,67 @@ export async function getSessionWithConnectivityAndEvents(supabase, sessionId) {
         events: eventsResult,
     };
 }
+// Get session with connectivity and events with tags using RPC functions
+export async function getSessionWithConnectivityAndEventsWithTags(supabase, sessionId, limit = 50, offset = 0, herdId) {
+    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}`);
+        }
+        // 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
+        const { data: sessionData, error: sessionError } = await supabase
+            .from("sessions")
+            .select("*")
+            .eq("id", sessionId)
+            .single();
+        if (sessionError) {
+            throw new Error(`Failed to get session: ${sessionError.message}`);
+        }
+        // Get the device to find its herd_id
+        const { data: device, error: deviceError } = await supabase
+            .from("devices")
+            .select("herd_id")
+            .eq("id", sessionData.device_id)
+            .single();
+        if (deviceError) {
+            throw new Error(`Failed to get device: ${deviceError.message}`);
+        }
+        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}`);
+        }
+        // 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),
+    ]);
+    return {
+        session: sessionWithCoords,
+        connectivity: connectivityResult,
+        eventsWithTags: eventsWithTagsResult,
+        totalEvents: totalEventsResult,
+    };
+}
 // Get sessions for a device using RPC function
 export async function getSessionsByDeviceId(supabase, deviceId) {
     const { data, error } = await supabase.rpc("get_sessions_with_coordinates_by_device", {

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -403,6 +403,12 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 isOneToOne: false;
                 referencedRelation: "events_with_tags";
                 referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "tags_event_id_fkey";
+                columns: ["event_id"];
+                isOneToOne: false;
+                referencedRelation: "events_with_tags_by_session";
+                referencedColumns: ["id"];
             }];
         };
         users: {
@@ -500,6 +506,46 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 media_type: Database["public"]["Enums"]["media_type"] | null;
                 media_url: string | null;
                 message: string | null;
+                session_id: number | null;
+                tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
+                timestamp_observation: string | null;
+            };
+            Relationships: [{
+                foreignKeyName: "devices_herd_id_fkey";
+                columns: ["herd_id"];
+                isOneToOne: false;
+                referencedRelation: "herds";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "events_device_id_fkey";
+                columns: ["device_id"];
+                isOneToOne: false;
+                referencedRelation: "devices";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "events_session_id_fkey";
+                columns: ["session_id"];
+                isOneToOne: false;
+                referencedRelation: "sessions";
+                referencedColumns: ["id"];
+            }];
+        };
+        events_with_tags_by_session: {
+            Row: {
+                altitude: number | null;
+                device_id: number | null;
+                earthranger_url: string | null;
+                file_path: string | null;
+                heading: number | null;
+                herd_id: number | null;
+                id: number | null;
+                inserted_at: string | null;
+                is_public: boolean | null;
+                location: unknown | null;
+                media_type: Database["public"]["Enums"]["media_type"] | null;
+                media_url: string | null;
+                message: string | null;
+                session_id: number | null;
                 tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
                 timestamp_observation: string | null;
             };
@@ -515,6 +561,12 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 isOneToOne: false;
                 referencedRelation: "devices";
                 referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "events_session_id_fkey";
+                columns: ["session_id"];
+                isOneToOne: false;
+                referencedRelation: "sessions";
+                referencedColumns: ["id"];
             }];
         };
         zones_and_actions: {
@@ -618,6 +670,14 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
             };
             Returns: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"][];
         };
+        get_events_and_tags_for_session: {
+            Args: {
+                session_id_caller: number;
+                limit_caller: number;
+                offset_caller: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"][];
+        };
         get_events_for_herd: {
             Args: {
                 herd_id_in: number;
@@ -671,6 +731,12 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
             };
             Returns: number;
         };
+        get_total_events_for_session: {
+            Args: {
+                session_id_caller: number;
+            };
+            Returns: number;
+        };
         get_zones_and_actions_for_herd: {
             Args: {
                 herd_id_caller: number;

package/dist/supabase/server.d.ts

@@ -401,6 +401,12 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 isOneToOne: false;
                 referencedRelation: "events_with_tags";
                 referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "tags_event_id_fkey";
+                columns: ["event_id"];
+                isOneToOne: false;
+                referencedRelation: "events_with_tags_by_session";
+                referencedColumns: ["id"];
             }];
         };
         users: {
@@ -498,6 +504,46 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 media_type: Database["public"]["Enums"]["media_type"] | null;
                 media_url: string | null;
                 message: string | null;
+                session_id: number | null;
+                tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
+                timestamp_observation: string | null;
+            };
+            Relationships: [{
+                foreignKeyName: "devices_herd_id_fkey";
+                columns: ["herd_id"];
+                isOneToOne: false;
+                referencedRelation: "herds";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "events_device_id_fkey";
+                columns: ["device_id"];
+                isOneToOne: false;
+                referencedRelation: "devices";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "events_session_id_fkey";
+                columns: ["session_id"];
+                isOneToOne: false;
+                referencedRelation: "sessions";
+                referencedColumns: ["id"];
+            }];
+        };
+        events_with_tags_by_session: {
+            Row: {
+                altitude: number | null;
+                device_id: number | null;
+                earthranger_url: string | null;
+                file_path: string | null;
+                heading: number | null;
+                herd_id: number | null;
+                id: number | null;
+                inserted_at: string | null;
+                is_public: boolean | null;
+                location: unknown | null;
+                media_type: Database["public"]["Enums"]["media_type"] | null;
+                media_url: string | null;
+                message: string | null;
+                session_id: number | null;
                 tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
                 timestamp_observation: string | null;
             };
@@ -513,6 +559,12 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 isOneToOne: false;
                 referencedRelation: "devices";
                 referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "events_session_id_fkey";
+                columns: ["session_id"];
+                isOneToOne: false;
+                referencedRelation: "sessions";
+                referencedColumns: ["id"];
             }];
         };
         zones_and_actions: {
@@ -616,6 +668,14 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
             };
             Returns: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"][];
         };
+        get_events_and_tags_for_session: {
+            Args: {
+                session_id_caller: number;
+                limit_caller: number;
+                offset_caller: number;
+            };
+            Returns: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"][];
+        };
         get_events_for_herd: {
             Args: {
                 herd_id_in: number;
@@ -669,6 +729,12 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
             };
             Returns: number;
         };
+        get_total_events_for_session: {
+            Args: {
+                session_id_caller: number;
+            };
+            Returns: number;
+        };
         get_zones_and_actions_for_herd: {
             Args: {
                 herd_id_caller: number;

package/dist/types/supabase.d.ts

@@ -451,6 +451,13 @@ export type Database = {
                         isOneToOne: false;
                         referencedRelation: "events_with_tags";
                         referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "tags_event_id_fkey";
+                        columns: ["event_id"];
+                        isOneToOne: false;
+                        referencedRelation: "events_with_tags_by_session";
+                        referencedColumns: ["id"];
                     }
                 ];
             };
@@ -554,6 +561,50 @@ export type Database = {
                     media_type: Database["public"]["Enums"]["media_type"] | null;
                     media_url: string | null;
                     message: string | null;
+                    session_id: number | null;
+                    tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
+                    timestamp_observation: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "devices_herd_id_fkey";
+                        columns: ["herd_id"];
+                        isOneToOne: false;
+                        referencedRelation: "herds";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "events_device_id_fkey";
+                        columns: ["device_id"];
+                        isOneToOne: false;
+                        referencedRelation: "devices";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "events_session_id_fkey";
+                        columns: ["session_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sessions";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
+            events_with_tags_by_session: {
+                Row: {
+                    altitude: number | null;
+                    device_id: number | null;
+                    earthranger_url: string | null;
+                    file_path: string | null;
+                    heading: number | null;
+                    herd_id: number | null;
+                    id: number | null;
+                    inserted_at: string | null;
+                    is_public: boolean | null;
+                    location: unknown | null;
+                    media_type: Database["public"]["Enums"]["media_type"] | null;
+                    media_url: string | null;
+                    message: string | null;
+                    session_id: number | null;
                     tags: Database["public"]["Tables"]["tags"]["Row"][] | null;
                     timestamp_observation: string | null;
                 };
@@ -571,6 +622,13 @@ export type Database = {
                         isOneToOne: false;
                         referencedRelation: "devices";
                         referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "events_session_id_fkey";
+                        columns: ["session_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sessions";
+                        referencedColumns: ["id"];
                     }
                 ];
             };
@@ -677,6 +735,14 @@ export type Database = {
                 };
                 Returns: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"][];
             };
+            get_events_and_tags_for_session: {
+                Args: {
+                    session_id_caller: number;
+                    limit_caller: number;
+                    offset_caller: number;
+                };
+                Returns: Database["public"]["CompositeTypes"]["event_and_tags_pretty_location"][];
+            };
             get_events_for_herd: {
                 Args: {
                     herd_id_in: number;
@@ -730,6 +796,12 @@ export type Database = {
                 };
                 Returns: number;
             };
+            get_total_events_for_session: {
+                Args: {
+                    session_id_caller: number;
+                };
+                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.32",
+  "version": "1.0.33",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",