@adventurelabs/scout-core 1.0.80 → 1.0.83

package/dist/helpers/cache.d.ts

@@ -47,6 +47,8 @@ export declare class ScoutCache {
         reason: string;
     }>;
     preloadCache(loadFunction: () => Promise<IHerdModule[]>, ttlMs?: number): Promise<void>;
+    getProvidersForHerd(herdId: string): Promise<CacheResult<any[]>>;
+    setProvidersForHerd(herdId: string, providers: any[], ttlMs?: number): Promise<void>;
     getDefaultTtl(): number;
 }
 export declare const scoutCache: ScoutCache;

package/dist/helpers/cache.js

@@ -2,6 +2,7 @@ const DB_NAME = "ScoutCache";
 const DB_VERSION = 1;
 const HERD_MODULES_STORE = "herd_modules";
 const CACHE_METADATA_STORE = "cache_metadata";
+const PROVIDERS_STORE = "providers";
 // Default TTL: 24 hours (1 day)
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 export class ScoutCache {
@@ -46,6 +47,15 @@ export class ScoutCache {
                         keyPath: "key",
                     });
                 }
+                // Create providers store
+                if (!db.objectStoreNames.contains(PROVIDERS_STORE)) {
+                    const providersStore = db.createObjectStore(PROVIDERS_STORE, {
+                        keyPath: "herdId",
+                    });
+                    providersStore.createIndex("timestamp", "timestamp", {
+                        unique: false,
+                    });
+                }
                 console.log("[ScoutCache] Database schema upgraded");
             };
         });
@@ -55,15 +65,16 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
+        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE, PROVIDERS_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
             transaction.oncomplete = () => resolve();
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            const providersStore = transaction.objectStore(PROVIDERS_STORE);
             const timestamp = Date.now();
             const version = "1.0.0";
-            // Store each herd module
+            // Store each herd module and its providers
             herdModules.forEach((herdModule) => {
                 const cacheEntry = {
                     herdId: herdModule.herd.id.toString(),
@@ -71,6 +82,15 @@ export class ScoutCache {
                     timestamp,
                 };
                 herdModulesStore.put(cacheEntry);
+                // Store providers separately for easier querying
+                if (herdModule.providers && herdModule.providers.length > 0) {
+                    const providersCacheEntry = {
+                        herdId: herdModule.herd.id.toString(),
+                        data: herdModule.providers,
+                        timestamp,
+                    };
+                    providersStore.put(providersCacheEntry);
+                }
             });
             // Store cache metadata
             const metadata = {
@@ -82,6 +102,16 @@ export class ScoutCache {
                 lastModified: timestamp,
             };
             metadataStore.put(metadata);
+            // Store providers metadata
+            const providersMetadata = {
+                key: "providers",
+                timestamp,
+                ttl: ttlMs,
+                version,
+                etag,
+                lastModified: timestamp,
+            };
+            metadataStore.put(providersMetadata);
         });
     }
     async getHerdModules() {
@@ -134,14 +164,17 @@ export class ScoutCache {
         await this.init();
         if (!this.db)
             throw new Error("Database not initialized");
-        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE], "readwrite");
+        const transaction = this.db.transaction([HERD_MODULES_STORE, CACHE_METADATA_STORE, PROVIDERS_STORE], "readwrite");
         return new Promise((resolve, reject) => {
             transaction.onerror = () => reject(transaction.error);
             transaction.oncomplete = () => resolve();
             const herdModulesStore = transaction.objectStore(HERD_MODULES_STORE);
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            const providersStore = transaction.objectStore(PROVIDERS_STORE);
             herdModulesStore.clear();
+            providersStore.clear();
             metadataStore.delete("herd_modules");
+            metadataStore.delete("providers");
         });
     }
     async invalidateHerdModules() {
@@ -154,6 +187,7 @@ export class ScoutCache {
             transaction.oncomplete = () => resolve();
             const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
             metadataStore.delete("herd_modules");
+            metadataStore.delete("providers");
         });
     }
     async getCacheStats() {
@@ -214,6 +248,81 @@ export class ScoutCache {
             console.warn("[ScoutCache] Background preload failed:", error);
         }
     }
+    // Method to get providers for a specific herd from cache
+    async getProvidersForHerd(herdId) {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const transaction = this.db.transaction([PROVIDERS_STORE, CACHE_METADATA_STORE], "readonly");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            const providersStore = transaction.objectStore(PROVIDERS_STORE);
+            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            // Get metadata first
+            const metadataRequest = metadataStore.get("providers");
+            metadataRequest.onsuccess = () => {
+                const metadata = metadataRequest.result;
+                const now = Date.now();
+                if (!metadata) {
+                    this.stats.misses++;
+                    resolve({ data: null, isStale: true, age: 0, metadata: null });
+                    return;
+                }
+                const age = now - metadata.timestamp;
+                const isStale = age > metadata.ttl;
+                // Get providers for specific herd
+                const getRequest = providersStore.get(herdId);
+                getRequest.onsuccess = () => {
+                    const cacheEntry = getRequest.result;
+                    const providers = cacheEntry?.data || [];
+                    // Update stats
+                    if (providers.length > 0) {
+                        this.stats.hits++;
+                    }
+                    else {
+                        this.stats.misses++;
+                    }
+                    resolve({
+                        data: providers,
+                        isStale,
+                        age,
+                        metadata,
+                    });
+                };
+            };
+        });
+    }
+    // Method to set providers for a specific herd
+    async setProvidersForHerd(herdId, providers, ttlMs = DEFAULT_TTL_MS) {
+        await this.init();
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const transaction = this.db.transaction([PROVIDERS_STORE, CACHE_METADATA_STORE], "readwrite");
+        return new Promise((resolve, reject) => {
+            transaction.onerror = () => reject(transaction.error);
+            transaction.oncomplete = () => resolve();
+            const providersStore = transaction.objectStore(PROVIDERS_STORE);
+            const metadataStore = transaction.objectStore(CACHE_METADATA_STORE);
+            const timestamp = Date.now();
+            const version = "1.0.0";
+            // Store providers
+            const providersCacheEntry = {
+                herdId,
+                data: providers,
+                timestamp,
+            };
+            providersStore.put(providersCacheEntry);
+            // Update providers metadata
+            const metadata = {
+                key: "providers",
+                timestamp,
+                ttl: ttlMs,
+                version,
+                lastModified: timestamp,
+            };
+            metadataStore.put(metadata);
+        });
+    }
     // Get the default TTL value
     getDefaultTtl() {
         return DEFAULT_TTL_MS;

package/dist/helpers/devices.d.ts

@@ -1,8 +1,9 @@
-import { IDevice } from "../types/db";
+import { Database } from "@/types";
+import { DeviceInsert, IDevice } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
-export declare function get_devices_by_herd(herd_id: number, client: SupabaseClient): Promise<IWebResponseCompatible<IDevice[]>>;
-export declare function get_device_by_id(device_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IDevice | null>>;
+export declare function get_devices_by_herd(herd_id: number, client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IDevice[]>>;
+export declare function get_device_by_id(device_id: number, client?: SupabaseClient<Database>): Promise<IWebResponseCompatible<IDevice | null>>;
 export declare function serverUpdateDevice(updatedDevice: IDevice): Promise<IWebResponseCompatible<IDevice | null>>;
-export declare function serverCreateDevice(newDevice: any): Promise<IWebResponseCompatible<IDevice | null>>;
+export declare function serverCreateDevice(newDevice: DeviceInsert): Promise<IWebResponseCompatible<IDevice | null>>;
 export declare function serverDeleteDeviceById(device_id: number): Promise<IWebResponseCompatible<IDevice | null>>;

package/dist/helpers/devices.js

@@ -60,6 +60,9 @@ export async function serverCreateDevice(newDevice) {
     const supabase = await newServerClient();
     const user = await supabase.auth.getUser();
     const userId = user?.data?.user?.id;
+    if (!userId) {
+        return IWebResponse.error("User not found").to_compatible();
+    }
     newDevice.created_by = userId;
     // strip id field from herd object
     const { data, error } = await supabase

package/dist/helpers/providers.d.ts

@@ -0,0 +1,6 @@
+import { IProvider } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_providers_by_herd(herd_id: number): Promise<IWebResponseCompatible<IProvider[]>>;
+export declare function server_create_provider(provider: Omit<IProvider, "id" | "created_at">): Promise<IWebResponseCompatible<IProvider>>;
+export declare function server_update_provider(provider_id: number, updates: Partial<Omit<IProvider, "id" | "created_at">>): Promise<IWebResponseCompatible<IProvider>>;
+export declare function server_delete_providers_by_ids(provider_ids: number[]): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/providers.js

@@ -0,0 +1,78 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+// function that fetches the providers from our db given a herd id
+export async function server_get_providers_by_herd(herd_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("providers")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+// function that creates a new provider in our db
+export async function server_create_provider(provider) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("providers")
+        .insert(provider)
+        .select("*")
+        .single();
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+// function that updates a provider in our db
+export async function server_update_provider(provider_id, updates) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("providers")
+        .update(updates)
+        .eq("id", provider_id)
+        .select("*")
+        .single();
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+// function that deletes providers by ids
+export async function server_delete_providers_by_ids(provider_ids) {
+    const supabase = await newServerClient();
+    const { error } = await supabase
+        .from("providers")
+        .delete()
+        .in("id", provider_ids);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
+    }
+    else {
+        return IWebResponse.success(true).to_compatible();
+    }
+}

package/dist/helpers/sessions.js

@@ -152,7 +152,8 @@ export async function server_upsert_sessions(sessionsData) {
     if (updates.length > 0) {
         for (const sessionData of updates) {
             const updateResult = await server_upsert_session(sessionData);
-            if (updateResult.status === EnumWebResponse.SUCCESS && updateResult.data) {
+            if (updateResult.status === EnumWebResponse.SUCCESS &&
+                updateResult.data) {
                 results.push(updateResult.data);
             }
             else {
@@ -233,7 +234,8 @@ export async function server_upsert_connectivity_batch(connectivityDataArray) {
     if (updates.length > 0) {
         for (const connectivityData of updates) {
             const updateResult = await server_upsert_connectivity(connectivityData);
-            if (updateResult.status === EnumWebResponse.SUCCESS && updateResult.data) {
+            if (updateResult.status === EnumWebResponse.SUCCESS &&
+                updateResult.data) {
                 results.push(updateResult.data);
             }
             else {
@@ -266,8 +268,10 @@ export async function server_get_session_with_connectivity_and_events(sessionId,
     if (herdId) {
         // Use provided herd ID directly
         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;
+        if (sessionsResult.status === EnumWebResponse.SUCCESS &&
+            sessionsResult.data) {
+            sessionWithCoords =
+                sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
     }
     else {
@@ -308,16 +312,22 @@ export async function server_get_session_with_connectivity_and_events(sessionId,
             };
         }
         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;
+        if (sessionsResult.status === EnumWebResponse.SUCCESS &&
+            sessionsResult.data) {
+            sessionWithCoords =
+                sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
     }
     const [connectivityResult, eventsResult] = await Promise.all([
         server_get_connectivity_by_session_id(sessionId),
         server_get_events_by_session_id(sessionId),
     ]);
-    const connectivity = connectivityResult.status === EnumWebResponse.SUCCESS ? connectivityResult.data || [] : [];
-    const events = eventsResult.status === EnumWebResponse.SUCCESS ? eventsResult.data || [] : [];
+    const connectivity = connectivityResult.status === EnumWebResponse.SUCCESS
+        ? connectivityResult.data || []
+        : [];
+    const events = eventsResult.status === EnumWebResponse.SUCCESS
+        ? eventsResult.data || []
+        : [];
     return IWebResponse.success({
         session: sessionWithCoords,
         connectivity,
@@ -333,8 +343,10 @@ export async function server_get_session_with_connectivity_and_events_with_tags(
         // Use provided herd ID directly
         actualHerdId = herdId;
         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;
+        if (sessionsResult.status === EnumWebResponse.SUCCESS &&
+            sessionsResult.data) {
+            sessionWithCoords =
+                sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
     }
     else {
@@ -378,8 +390,10 @@ export async function server_get_session_with_connectivity_and_events_with_tags(
         }
         actualHerdId = device.herd_id;
         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;
+        if (sessionsResult.status === EnumWebResponse.SUCCESS &&
+            sessionsResult.data) {
+            sessionWithCoords =
+                sessionsResult.data.find((s) => s.id === sessionId) || null;
         }
     }
     const [connectivityResult, eventsWithTagsResult, totalEventsResult] = await Promise.all([
@@ -387,9 +401,15 @@ export async function server_get_session_with_connectivity_and_events_with_tags(
         server_get_events_and_tags_by_session_id(sessionId, limit, offset),
         server_get_total_events_for_session(sessionId),
     ]);
-    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;
+    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,

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -8,7 +8,7 @@ interface ConnectionStatus {
     retryCount: number;
     reconnect: () => void;
 }
-export declare function useSupabase(): SupabaseClient<Database, "public", {
+export declare function useSupabase(): SupabaseClient<Database, "public", "public", {
     Tables: {
         actions: {
             Row: {
@@ -397,6 +397,39 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 referencedColumns: ["id"];
             }];
         };
+        providers: {
+            Row: {
+                created_at: string;
+                herd_id: number;
+                id: number;
+                key: string | null;
+                source: string;
+                type: string;
+            };
+            Insert: {
+                created_at?: string;
+                herd_id: number;
+                id?: number;
+                key?: string | null;
+                source: string;
+                type: string;
+            };
+            Update: {
+                created_at?: string;
+                herd_id?: number;
+                id?: number;
+                key?: string | null;
+                source?: string;
+                type?: string;
+            };
+            Relationships: [{
+                foreignKeyName: "providers_herd_id_fkey";
+                columns: ["herd_id"];
+                isOneToOne: false;
+                referencedRelation: "herds";
+                referencedColumns: ["id"];
+            }];
+        };
         sessions: {
             Row: {
                 altitude_average: number;
@@ -408,9 +441,9 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 earthranger_url: string | null;
                 id: number;
                 inserted_at: string;
-                locations: unknown;
+                locations: unknown | null;
                 software_version: string;
-                timestamp_end: string;
+                timestamp_end: string | null;
                 timestamp_start: string;
                 velocity_average: number;
                 velocity_max: number;
@@ -426,9 +459,9 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 earthranger_url?: string | null;
                 id?: number;
                 inserted_at?: string;
-                locations: unknown;
+                locations?: unknown | null;
                 software_version: string;
-                timestamp_end: string;
+                timestamp_end?: string | null;
                 timestamp_start: string;
                 velocity_average: number;
                 velocity_max: number;
@@ -444,9 +477,9 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
                 earthranger_url?: string | null;
                 id?: number;
                 inserted_at?: string;
-                locations?: unknown;
+                locations?: unknown | null;
                 software_version?: string;
-                timestamp_end?: string;
+                timestamp_end?: string | null;
                 timestamp_start?: string;
                 velocity_average?: number;
                 velocity_max?: number;
@@ -829,7 +862,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
         device_type: "trail_camera" | "drone_fixed_wing" | "drone_quad" | "gps_tracker" | "sentry_tower" | "smart_buoy" | "radio_mesh_base_station" | "radio_mesh_repeater" | "unknown";
         media_type: "image" | "video" | "audio" | "text";
         plan_type: "mission" | "fence" | "rally" | "markov";
-        role: "admin" | "viewer" | "editor";
+        role: "admin" | "viewer" | "editor" | "operator";
         tag_observation_type: "manual" | "auto";
         user_status: "ONLINE" | "OFFLINE";
     };
@@ -970,6 +1003,8 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
             actions: Database["public"]["Tables"]["actions"]["Row"][] | null;
         };
     };
+}, {
+    PostgrestVersion: "13.0.5";
 }>;
 export declare function useConnectionStatus(): ConnectionStatus;
 export interface ScoutRefreshProviderProps {

package/dist/store/hooks.d.ts

@@ -1,4 +1,4 @@
-export declare const useAppDispatch: <AppDispatch extends import("redux").Dispatch<import("redux").AnyAction> = import("redux").Dispatch<import("redux").AnyAction>>() => AppDispatch;
+export declare const useAppDispatch: import("react-redux").UseDispatch<import("redux").Dispatch<import("redux").UnknownAction>>;
 export declare const useHerdModulesLoadingState: () => any;
 export declare const useIsHerdModulesLoading: () => boolean;
 export declare const useIsHerdModulesLoaded: () => boolean;