@adventurelabs/scout-core 1.0.82 → 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/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/providers/ScoutRefreshProvider.d.ts

@@ -397,6 +397,39 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 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;

package/dist/types/db.d.ts

@@ -21,6 +21,7 @@ export type IUserRolePerHerd = Database["public"]["Tables"]["users_roles_per_her
 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 IProvider = Database["public"]["Tables"]["providers"]["Row"];
 export type IEventWithTags = Database["public"]["CompositeTypes"]["event_with_tags"] & {
     earthranger_url: string | null;
     file_path: string | null;

package/dist/types/herd_module.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IProvider, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
 import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
     NOT_LOADING = "NOT_LOADING",
@@ -21,7 +21,8 @@ export declare class HerdModule {
     labels: string[];
     plans: IPlan[];
     layers: ILayer[];
-    constructor(herd: IHerd, devices: IDevice[], events: IEventWithTags[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, events_page_index?: number, total_events?: number, total_events_with_filters?: number, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], sessions?: ISessionWithCoordinates[], layers?: ILayer[]);
+    providers: IProvider[];
+    constructor(herd: IHerd, devices: IDevice[], events: IEventWithTags[], timestamp_last_refreshed: number, user_roles?: IUserAndRole[] | null, events_page_index?: number, total_events?: number, total_events_with_filters?: number, labels?: string[], plans?: IPlan[], zones?: IZoneWithActions[], sessions?: ISessionWithCoordinates[], layers?: ILayer[], providers?: IProvider[]);
     to_serializable(): IHerdModule;
     static from_herd(herd: IHerd, client: SupabaseClient): Promise<HerdModule>;
 }
@@ -39,6 +40,7 @@ export interface IHerdModule {
     zones: IZoneWithActions[];
     sessions: ISessionWithCoordinates[];
     layers: ILayer[];
+    providers: IProvider[];
 }
 export interface IHerdModulesResponse {
     data: IHerdModule[];

package/dist/types/herd_module.js

@@ -4,6 +4,7 @@ import { server_get_total_events_by_herd } from "../helpers/events";
 import { EnumSessionsVisibility } from "./events";
 import { server_get_plans_by_herd } from "../helpers/plans";
 import { server_get_layers_by_herd } from "../helpers/layers";
+import { server_get_providers_by_herd } from "../helpers/providers";
 import { server_get_events_and_tags_for_devices_batch } from "../helpers/tags";
 import { server_get_users_with_herd_access } from "../helpers/users";
 import { EnumWebResponse } from "./requests";
@@ -18,7 +19,7 @@ export var EnumHerdModulesLoadingState;
     EnumHerdModulesLoadingState["UNSUCCESSFULLY_LOADED"] = "UNSUCCESSFULLY_LOADED";
 })(EnumHerdModulesLoadingState || (EnumHerdModulesLoadingState = {}));
 export class HerdModule {
-    constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = []) {
+    constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = [], providers = []) {
         this.user_roles = null;
         this.events_page_index = 0;
         this.total_events = 0;
@@ -26,6 +27,7 @@ export class HerdModule {
         this.labels = [];
         this.plans = [];
         this.layers = [];
+        this.providers = [];
         this.herd = herd;
         this.devices = devices;
         this.events = events;
@@ -39,6 +41,7 @@ export class HerdModule {
         this.zones = zones;
         this.sessions = sessions;
         this.layers = layers;
+        this.providers = providers;
     }
     to_serializable() {
         return {
@@ -55,6 +58,7 @@ export class HerdModule {
             zones: this.zones,
             sessions: this.sessions,
             layers: this.layers,
+            providers: this.providers,
         };
     }
     static async from_herd(herd, client) {
@@ -95,7 +99,7 @@ export class HerdModule {
                 }
             }
             // Run all remaining requests in parallel with individual error handling
-            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers,] = await Promise.allSettled([
+            const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions, res_layers, res_providers,] = await Promise.allSettled([
                 server_get_more_zones_and_actions_for_herd(herd.id, 0, 10).catch((error) => {
                     console.warn(`[HerdModule] Failed to get zones and actions:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
@@ -114,12 +118,20 @@ export class HerdModule {
                 }),
                 server_get_sessions_by_herd_id(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get sessions:`, error);
-                    return { status: EnumWebResponse.ERROR, data: [], msg: error.message };
+                    return {
+                        status: EnumWebResponse.ERROR,
+                        data: [],
+                        msg: error.message,
+                    };
                 }),
                 server_get_layers_by_herd(herd.id).catch((error) => {
                     console.warn(`[HerdModule] Failed to get layers:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
+                server_get_providers_by_herd(herd.id).catch((error) => {
+                    console.warn(`[HerdModule] Failed to get providers:`, error);
+                    return { status: EnumWebResponse.ERROR, data: null };
+                }),
             ]);
             // Assign recent events to devices from batch results
             for (let i = 0; i < new_devices.length; i++) {
@@ -148,23 +160,28 @@ export class HerdModule {
             const plans = res_plans.status === "fulfilled" && res_plans.value?.data
                 ? res_plans.value.data
                 : [];
-            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data ? res_sessions.value.data : [];
+            const sessions = res_sessions.status === "fulfilled" && res_sessions.value?.data
+                ? res_sessions.value.data
+                : [];
             const layers = res_layers.status === "fulfilled" && res_layers.value?.data
                 ? res_layers.value.data
                 : [];
+            const providers = res_providers.status === "fulfilled" && res_providers.value?.data
+                ? res_providers.value.data
+                : [];
             // TODO: store in DB and retrieve on load?
             const newLabels = LABELS;
             const endTime = Date.now();
             const loadTime = endTime - startTime;
             console.log(`[HerdModule] Loaded herd ${herd.slug} in ${loadTime}ms (${new_devices.length} devices)`);
-            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers);
+            return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions, layers, providers);
         }
         catch (error) {
             const endTime = Date.now();
             const loadTime = endTime - startTime;
             console.error(`[HerdModule] Critical error in HerdModule.from_herd (${loadTime}ms):`, error);
             // Return a minimal but valid HerdModule instance to prevent complete failure
-            return new HerdModule(herd, [], [], Date.now(), null, 0, 0, 0, [], [], [], [], []);
+            return new HerdModule(herd, [], [], Date.now(), null, 0, 0, 0, [], [], [], [], [], []);
         }
     }
 }

package/dist/types/supabase.d.ts

@@ -416,6 +416,41 @@ export type Database = {
                     }
                 ];
             };
+            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;

package/package.json

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