@adventurelabs/scout-core 1.0.24 → 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/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;
@@ -113,6 +167,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
                 message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             };
             Insert: {
@@ -128,6 +183,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
                 message?: string | null;
+                session_id?: number | null;
                 timestamp_observation?: string;
             };
             Update: {
@@ -143,6 +199,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
                 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;
@@ -506,6 +629,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
                 message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             }[];
         };

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;
@@ -111,6 +165,7 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
                 message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             };
             Insert: {
@@ -126,6 +181,7 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
                 message?: string | null;
+                session_id?: number | null;
                 timestamp_observation?: string;
             };
             Update: {
@@ -141,6 +197,7 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 media_type?: Database["public"]["Enums"]["media_type"];
                 media_url?: string | null;
                 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;
@@ -504,6 +627,7 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
                 media_type: Database["public"]["Enums"]["media_type"];
                 media_url: string | null;
                 message: string | null;
+                session_id: number | null;
                 timestamp_observation: string;
             }[];
         };

package/dist/types/db.d.ts

@@ -16,6 +16,8 @@ export type IAction = Database["public"]["Tables"]["actions"]["Row"];
 export type IZone = Database["public"]["Tables"]["zones"]["Row"];
 export type IUserRolePerHerd = Database["public"]["Tables"]["users_roles_per_herd"]["Row"];
 export type IHerd = Database["public"]["Tables"]["herds"]["Row"];
+export type ISession = Database["public"]["Tables"]["sessions"]["Row"];
+export type IConnectivity = Database["public"]["Tables"]["connectivity"]["Row"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
     file_path: string | null;
@@ -26,6 +28,22 @@ export type IZonesAndActionsPrettyLocation = Database["public"]["CompositeTypes"
 export interface IZoneWithActions extends IZone {
     actions: IAction[];
 }
+export interface ISessionWithConnectivity extends ISession {
+    connectivity: IConnectivity[];
+}
+export interface ISessionWithEvents extends ISession {
+    events: IEvent[];
+}
+export interface ISessionWithConnectivityAndEvents extends ISession {
+    connectivity: IConnectivity[];
+    events: IEvent[];
+}
+export interface IConnectivityWithSession extends IConnectivity {
+    session: ISession;
+}
+export interface IEventWithSession extends IEvent {
+    session: ISession | null;
+}
 export type IUserAndRole = {
     user: {
         id: string;
@@ -40,4 +58,3 @@ export interface IApiKeyScout {
 }
 export type Tag = ITag;
 export type TagClassName = string;
-export declare const DUMMY_EVENT: IEvent;

package/dist/types/db.js

@@ -1,16 +1 @@
-// Dummy event for testing/development
-export const DUMMY_EVENT = {
-    id: 0,
-    inserted_at: new Date().toISOString(),
-    device_id: 0,
-    message: "Dummy event",
-    media_url: "",
-    media_type: "image",
-    location: null,
-    altitude: 0,
-    heading: 0,
-    is_public: true,
-    timestamp_observation: new Date().toISOString(),
-    earthranger_url: null,
-    file_path: null,
-};
+export {};