@adventurelabs/scout-core 1.0.23 → 1.0.25

package/dist/helpers/sessions.d.ts

@@ -0,0 +1,30 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { ISession, IConnectivity, IEvent } from "../types/db";
+export type SessionInput = Omit<ISession, "id" | "inserted_at">;
+export type SessionUpdateInput = Partial<SessionInput> & {
+    id: number;
+};
+export type SessionUpsertInput = SessionInput | SessionUpdateInput;
+export type ConnectivityInput = Omit<IConnectivity, "id" | "inserted_at">;
+export type ConnectivityUpdateInput = Partial<ConnectivityInput> & {
+    id: number;
+};
+export type ConnectivityUpsertInput = ConnectivityInput | ConnectivityUpdateInput;
+export declare function getSessionsByHerdId(supabase: SupabaseClient<Database>, herdId: number): Promise<ISession[]>;
+export declare function getConnectivityBySessionId(supabase: SupabaseClient<Database>, sessionId: number): Promise<IConnectivity[]>;
+export declare function getEventsBySessionId(supabase: SupabaseClient<Database>, sessionId: number): Promise<IEvent[]>;
+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<{
+    session: ISession;
+    connectivity: IConnectivity[];
+    events: IEvent[];
+}>;
+export declare function getSessionsByDeviceId(supabase: SupabaseClient<Database>, deviceId: number): Promise<ISession[]>;
+export declare function deleteSession(supabase: SupabaseClient<Database>, sessionId: number): Promise<void>;
+export declare function deleteSessions(supabase: SupabaseClient<Database>, sessionIds: number[]): Promise<void>;
+export declare function deleteConnectivity(supabase: SupabaseClient<Database>, connectivityId: number): Promise<void>;
+export declare function deleteConnectivityBatch(supabase: SupabaseClient<Database>, connectivityIds: number[]): Promise<void>;

package/dist/helpers/sessions.js

@@ -0,0 +1,241 @@
+// Get sessions by herd id
+export async function getSessionsByHerdId(supabase, herdId) {
+    const { data, error } = await supabase
+        .from("sessions")
+        .select(`
+      *,
+      devices!inner(herd_id)
+    `)
+        .eq("devices.herd_id", herdId)
+        .order("timestamp_start", { ascending: false });
+    if (error) {
+        throw new Error(`Failed to get sessions by herd id: ${error.message}`);
+    }
+    return data || [];
+}
+// Get connectivity by session id
+export async function getConnectivityBySessionId(supabase, sessionId) {
+    const { data, error } = await supabase
+        .from("connectivity")
+        .select("*")
+        .eq("session_id", sessionId)
+        .order("timestamp_start", { ascending: true });
+    if (error) {
+        throw new Error(`Failed to get connectivity by session id: ${error.message}`);
+    }
+    return data || [];
+}
+// Get events by session id
+export async function getEventsBySessionId(supabase, sessionId) {
+    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}`);
+    }
+    return data || [];
+}
+// Create or update session
+export async function upsertSession(supabase, sessionData) {
+    const isUpdate = "id" in sessionData;
+    if (isUpdate) {
+        // Update existing session
+        const { id, ...updateData } = sessionData;
+        const { data, error } = await supabase
+            .from("sessions")
+            .update(updateData)
+            .eq("id", id)
+            .select()
+            .single();
+        if (error) {
+            throw new Error(`Failed to update session: ${error.message}`);
+        }
+        return data;
+    }
+    else {
+        // Create new session
+        const { data, error } = await supabase
+            .from("sessions")
+            .insert(sessionData)
+            .select()
+            .single();
+        if (error) {
+            throw new Error(`Failed to create session: ${error.message}`);
+        }
+        return data;
+    }
+}
+// Batch upsert sessions
+export async function upsertSessions(supabase, sessionsData) {
+    if (sessionsData.length === 0) {
+        return [];
+    }
+    // Separate updates and inserts
+    const updates = sessionsData.filter((s) => "id" in s);
+    const inserts = sessionsData.filter((s) => !("id" in s));
+    const results = [];
+    // Handle updates
+    if (updates.length > 0) {
+        for (const sessionData of updates) {
+            try {
+                const result = await upsertSession(supabase, sessionData);
+                results.push(result);
+            }
+            catch (error) {
+                throw new Error(`Failed to update session ${sessionData.id}: ${error}`);
+            }
+        }
+    }
+    // Handle inserts
+    if (inserts.length > 0) {
+        const { data, error } = await supabase
+            .from("sessions")
+            .insert(inserts)
+            .select();
+        if (error) {
+            throw new Error(`Failed to create sessions: ${error.message}`);
+        }
+        results.push(...(data || []));
+    }
+    return results;
+}
+// Create or update connectivity
+export async function upsertConnectivity(supabase, connectivityData) {
+    const isUpdate = "id" in connectivityData;
+    if (isUpdate) {
+        // Update existing connectivity
+        const { id, ...updateData } = connectivityData;
+        const { data, error } = await supabase
+            .from("connectivity")
+            .update(updateData)
+            .eq("id", id)
+            .select()
+            .single();
+        if (error) {
+            throw new Error(`Failed to update connectivity: ${error.message}`);
+        }
+        return data;
+    }
+    else {
+        // Create new connectivity
+        const { data, error } = await supabase
+            .from("connectivity")
+            .insert(connectivityData)
+            .select()
+            .single();
+        if (error) {
+            throw new Error(`Failed to create connectivity: ${error.message}`);
+        }
+        return data;
+    }
+}
+// Batch upsert connectivity
+export async function upsertConnectivityBatch(supabase, connectivityDataArray) {
+    if (connectivityDataArray.length === 0) {
+        return [];
+    }
+    // Separate updates and inserts
+    const updates = connectivityDataArray.filter((c) => "id" in c);
+    const inserts = connectivityDataArray.filter((c) => !("id" in c));
+    const results = [];
+    // Handle updates
+    if (updates.length > 0) {
+        for (const connectivityData of updates) {
+            try {
+                const result = await upsertConnectivity(supabase, connectivityData);
+                results.push(result);
+            }
+            catch (error) {
+                throw new Error(`Failed to update connectivity ${connectivityData.id}: ${error}`);
+            }
+        }
+    }
+    // Handle inserts
+    if (inserts.length > 0) {
+        const { data, error } = await supabase
+            .from("connectivity")
+            .insert(inserts)
+            .select();
+        if (error) {
+            throw new Error(`Failed to create connectivity entries: ${error.message}`);
+        }
+        results.push(...(data || []));
+    }
+    return results;
+}
+// Get session with connectivity and events
+export async function getSessionWithConnectivityAndEvents(supabase, sessionId) {
+    const [sessionResult, connectivityResult, eventsResult] = await Promise.all([
+        supabase.from("sessions").select("*").eq("id", sessionId).single(),
+        getConnectivityBySessionId(supabase, sessionId),
+        getEventsBySessionId(supabase, sessionId),
+    ]);
+    if (sessionResult.error) {
+        throw new Error(`Failed to get session: ${sessionResult.error.message}`);
+    }
+    return {
+        session: sessionResult.data,
+        connectivity: connectivityResult,
+        events: eventsResult,
+    };
+}
+// Get sessions for a device
+export async function getSessionsByDeviceId(supabase, deviceId) {
+    const { data, error } = await supabase
+        .from("sessions")
+        .select("*")
+        .eq("device_id", deviceId)
+        .order("timestamp_start", { ascending: false });
+    if (error) {
+        throw new Error(`Failed to get sessions by device id: ${error.message}`);
+    }
+    return data || [];
+}
+// Delete session and all related data
+export async function deleteSession(supabase, sessionId) {
+    const { error } = await supabase
+        .from("sessions")
+        .delete()
+        .eq("id", sessionId);
+    if (error) {
+        throw new Error(`Failed to delete session: ${error.message}`);
+    }
+}
+// Batch delete sessions
+export async function deleteSessions(supabase, sessionIds) {
+    if (sessionIds.length === 0) {
+        return;
+    }
+    const { error } = await supabase
+        .from("sessions")
+        .delete()
+        .in("id", sessionIds);
+    if (error) {
+        throw new Error(`Failed to delete sessions: ${error.message}`);
+    }
+}
+// Delete connectivity entry
+export async function deleteConnectivity(supabase, connectivityId) {
+    const { error } = await supabase
+        .from("connectivity")
+        .delete()
+        .eq("id", connectivityId);
+    if (error) {
+        throw new Error(`Failed to delete connectivity: ${error.message}`);
+    }
+}
+// Batch delete connectivity entries
+export async function deleteConnectivityBatch(supabase, connectivityIds) {
+    if (connectivityIds.length === 0) {
+        return;
+    }
+    const { error } = await supabase
+        .from("connectivity")
+        .delete()
+        .in("id", connectivityIds);
+    if (error) {
+        throw new Error(`Failed to delete connectivity entries: ${error.message}`);
+    }
+}

package/dist/hooks/useScoutDbListener.js

@@ -12,6 +12,18 @@ export function useScoutDbListener(scoutSupabase) {
     }
     function handleTagDeletes(payload) {
         console.log("[DB Listener] Tag DELETE received:", payload.old);
+        console.log("[DB Listener] Tag DELETE - payload structure:", {
+            hasOld: !!payload.old,
+            oldId: payload.old?.id,
+            oldEventId: payload.old?.event_id,
+            oldClassName: payload.old?.class_name,
+            fullPayload: payload,
+        });
+        if (!payload.old || !payload.old.id) {
+            console.error("[DB Listener] Tag DELETE - Invalid payload, missing tag data");
+            return;
+        }
+        console.log("[DB Listener] Tag DELETE - Dispatching deleteTag action with ID:", payload.old.id);
         dispatch(deleteTag(payload.old));
     }
     function handleTagUpdates(payload) {

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -39,6 +39,60 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 referencedColumns: ["id"];
             }];
         };
+        connectivity: {
+            Row: {
+                altitude: number;
+                h11_index: number;
+                h12_index: number;
+                h13_index: number;
+                h14_index: number;
+                heading: number;
+                id: number;
+                inserted_at: string;
+                location: unknown;
+                noise: number;
+                session_id: number;
+                signal: number;
+                timestamp_start: string;
+            };
+            Insert: {
+                altitude: number;
+                h11_index: number;
+                h12_index: number;
+                h13_index: number;
+                h14_index: number;
+                heading: number;
+                id?: number;
+                inserted_at?: string;
+                location: unknown;
+                noise: number;
+                session_id: number;
+                signal: number;
+                timestamp_start: string;
+            };
+            Update: {
+                altitude?: number;
+                h11_index?: number;
+                h12_index?: number;
+                h13_index?: number;
+                h14_index?: number;
+                heading?: number;
+                id?: number;
+                inserted_at?: string;
+                location?: unknown;
+                noise?: number;
+                session_id?: number;
+                signal?: number;
+                timestamp_start?: string;
+            };
+            Relationships: [{
+                foreignKeyName: "connectivity_session_id_fkey";
+                columns: ["session_id"];
+                isOneToOne: false;
+                referencedRelation: "sessions";
+                referencedColumns: ["id"];
+            }];
+        };
         devices: {
             Row: {
                 altitude: number | null;
@@ -112,22 +166,24 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 location: unknown | null;
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
-                message: string;
+                message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             };
             Insert: {
-                altitude: number;
+                altitude?: number;
                 device_id: number;
                 earthranger_url?: string | null;
                 file_path?: string | null;
-                heading: number;
+                heading?: number;
                 id?: number;
                 inserted_at?: string;
                 is_public?: boolean;
                 location?: unknown | null;
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
-                message: string;
+                message?: string | null;
+                session_id?: number | null;
                 timestamp_observation?: string;
             };
             Update: {
@@ -142,7 +198,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 location?: unknown | null;
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
-                message?: string;
+                message?: string | null;
+                session_id?: number | null;
                 timestamp_observation?: string;
             };
             Relationships: [{
@@ -151,6 +208,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"];
             }];
         };
         herds: {
@@ -231,6 +294,66 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 referencedColumns: ["id"];
             }];
         };
+        sessions: {
+            Row: {
+                altitude_average: number;
+                altitude_max: number;
+                altitude_min: number;
+                device_id: number;
+                distance_max_from_start: number;
+                distance_total: number;
+                id: number;
+                inserted_at: string;
+                locations: unknown;
+                software_version: string;
+                timestamp_end: string;
+                timestamp_start: string;
+                velocity_average: number;
+                velocity_max: number;
+                velocity_min: number;
+            };
+            Insert: {
+                altitude_average: number;
+                altitude_max: number;
+                altitude_min: number;
+                device_id: number;
+                distance_max_from_start: number;
+                distance_total: number;
+                id?: number;
+                inserted_at?: string;
+                locations: unknown;
+                software_version: string;
+                timestamp_end: string;
+                timestamp_start: string;
+                velocity_average: number;
+                velocity_max: number;
+                velocity_min: number;
+            };
+            Update: {
+                altitude_average?: number;
+                altitude_max?: number;
+                altitude_min?: number;
+                device_id?: number;
+                distance_max_from_start?: number;
+                distance_total?: number;
+                id?: number;
+                inserted_at?: string;
+                locations?: unknown;
+                software_version?: string;
+                timestamp_end?: string;
+                timestamp_start?: string;
+                velocity_average?: number;
+                velocity_max?: number;
+                velocity_min?: number;
+            };
+            Relationships: [{
+                foreignKeyName: "sessions_device_id_fkey";
+                columns: ["device_id"];
+                isOneToOne: false;
+                referencedRelation: "devices";
+                referencedColumns: ["id"];
+            }];
+        };
         tags: {
             Row: {
                 class_name: string;
@@ -505,7 +628,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 location: unknown | null;
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
-                message: string;
+                message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             }[];
         };

package/dist/store/scout.js

@@ -76,19 +76,25 @@ export const scoutSlice = createSlice({
             }
         },
         deleteTag(state, action) {
+            console.log("[Redux] deleteTag action called with:", action.payload);
+            console.log("[Redux] deleteTag - Looking for tag ID:", action.payload.id);
             for (const herd_module of state.herd_modules) {
                 for (const event of herd_module.events) {
                     if (!event.tags) {
                         continue;
                     }
+                    console.log(`[Redux] deleteTag - Checking event ${event.id}, has ${event.tags.length} tags`);
                     for (const tag of event.tags) {
                         if (tag.id === action.payload.id) {
+                            console.log(`[Redux] deleteTag - Found tag ${tag.id} in event ${event.id}, removing it`);
                             event.tags = event.tags.filter((t) => t.id !== tag.id);
+                            console.log(`[Redux] deleteTag - After removal, event ${event.id} has ${event.tags.length} tags`);
                             return;
                         }
                     }
                 }
             }
+            console.log("[Redux] deleteTag - Tag not found in any event");
         },
         updateTag(state, action) {
             for (const herd_module of state.herd_modules) {

package/dist/supabase/server.d.ts

@@ -37,6 +37,60 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 referencedColumns: ["id"];
             }];
         };
+        connectivity: {
+            Row: {
+                altitude: number;
+                h11_index: number;
+                h12_index: number;
+                h13_index: number;
+                h14_index: number;
+                heading: number;
+                id: number;
+                inserted_at: string;
+                location: unknown;
+                noise: number;
+                session_id: number;
+                signal: number;
+                timestamp_start: string;
+            };
+            Insert: {
+                altitude: number;
+                h11_index: number;
+                h12_index: number;
+                h13_index: number;
+                h14_index: number;
+                heading: number;
+                id?: number;
+                inserted_at?: string;
+                location: unknown;
+                noise: number;
+                session_id: number;
+                signal: number;
+                timestamp_start: string;
+            };
+            Update: {
+                altitude?: number;
+                h11_index?: number;
+                h12_index?: number;
+                h13_index?: number;
+                h14_index?: number;
+                heading?: number;
+                id?: number;
+                inserted_at?: string;
+                location?: unknown;
+                noise?: number;
+                session_id?: number;
+                signal?: number;
+                timestamp_start?: string;
+            };
+            Relationships: [{
+                foreignKeyName: "connectivity_session_id_fkey";
+                columns: ["session_id"];
+                isOneToOne: false;
+                referencedRelation: "sessions";
+                referencedColumns: ["id"];
+            }];
+        };
         devices: {
             Row: {
                 altitude: number | null;
@@ -110,22 +164,24 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 location: unknown | null;
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
-                message: string;
+                message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             };
             Insert: {
-                altitude: number;
+                altitude?: number;
                 device_id: number;
                 earthranger_url?: string | null;
                 file_path?: string | null;
-                heading: number;
+                heading?: number;
                 id?: number;
                 inserted_at?: string;
                 is_public?: boolean;
                 location?: unknown | null;
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
-                message: string;
+                message?: string | null;
+                session_id?: number | null;
                 timestamp_observation?: string;
             };
             Update: {
@@ -140,7 +196,8 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 location?: unknown | null;
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
-                message?: string;
+                message?: string | null;
+                session_id?: number | null;
                 timestamp_observation?: string;
             };
             Relationships: [{
@@ -149,6 +206,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"];
             }];
         };
         herds: {
@@ -229,6 +292,66 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 referencedColumns: ["id"];
             }];
         };
+        sessions: {
+            Row: {
+                altitude_average: number;
+                altitude_max: number;
+                altitude_min: number;
+                device_id: number;
+                distance_max_from_start: number;
+                distance_total: number;
+                id: number;
+                inserted_at: string;
+                locations: unknown;
+                software_version: string;
+                timestamp_end: string;
+                timestamp_start: string;
+                velocity_average: number;
+                velocity_max: number;
+                velocity_min: number;
+            };
+            Insert: {
+                altitude_average: number;
+                altitude_max: number;
+                altitude_min: number;
+                device_id: number;
+                distance_max_from_start: number;
+                distance_total: number;
+                id?: number;
+                inserted_at?: string;
+                locations: unknown;
+                software_version: string;
+                timestamp_end: string;
+                timestamp_start: string;
+                velocity_average: number;
+                velocity_max: number;
+                velocity_min: number;
+            };
+            Update: {
+                altitude_average?: number;
+                altitude_max?: number;
+                altitude_min?: number;
+                device_id?: number;
+                distance_max_from_start?: number;
+                distance_total?: number;
+                id?: number;
+                inserted_at?: string;
+                locations?: unknown;
+                software_version?: string;
+                timestamp_end?: string;
+                timestamp_start?: string;
+                velocity_average?: number;
+                velocity_max?: number;
+                velocity_min?: number;
+            };
+            Relationships: [{
+                foreignKeyName: "sessions_device_id_fkey";
+                columns: ["device_id"];
+                isOneToOne: false;
+                referencedRelation: "devices";
+                referencedColumns: ["id"];
+            }];
+        };
         tags: {
             Row: {
                 class_name: string;
@@ -503,7 +626,8 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 location: unknown | null;
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
-                message: string;
+                message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             }[];
         };