@adventurelabs/scout-core 1.0.132 → 1.1.1

package/dist/helpers/versions_software.d.ts

@@ -3,7 +3,6 @@ import { IVersionsSoftware, VersionsSoftwareInsert } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 export declare function get_versions_software(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
-export declare function get_versions_software_with_cache(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
 export declare function get_versions_software_by_system(client: SupabaseClient<Database>, system: string): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
 export declare function create_version_software(client: SupabaseClient<Database>, newVersionSoftware: VersionsSoftwareInsert): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function update_version_software(client: SupabaseClient<Database>, version_id: number, updatedVersionSoftware: Partial<VersionsSoftwareInsert>): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;

package/dist/helpers/versions_software.js

@@ -13,35 +13,6 @@ export async function get_versions_software(client) {
     }
     return IWebResponse.success(data).to_compatible();
 }
-export async function get_versions_software_with_cache(client) {
-    try {
-        // Try to get from cache first
-        const cacheResult = await scoutCache.getVersionsSoftware();
-        if (cacheResult.data && !cacheResult.isStale) {
-            console.log(`[VersionsSoftware] Using cached data (${Math.round(cacheResult.age / 1000)}s old)`);
-            return IWebResponse.success(cacheResult.data).to_compatible();
-        }
-        // Cache miss or stale data - fetch from API
-        console.log("[VersionsSoftware] Cache miss or stale, fetching from API");
-        const apiResponse = await get_versions_software(client);
-        // If API request was successful, cache the result
-        if (apiResponse.status === "success" && apiResponse.data) {
-            try {
-                await scoutCache.setVersionsSoftware(apiResponse.data);
-                console.log(`[VersionsSoftware] Cached ${apiResponse.data.length} software versions`);
-            }
-            catch (cacheError) {
-                console.warn("[VersionsSoftware] Failed to cache data:", cacheError);
-                // Continue anyway, we still have the API data
-            }
-        }
-        return apiResponse;
-    }
-    catch (cacheError) {
-        console.warn("[VersionsSoftware] Cache error, falling back to API:", cacheError);
-        return get_versions_software(client);
-    }
-}
 export async function get_versions_software_by_system(client, system) {
     const { data, error } = await client
         .from("versions_software")

package/dist/hooks/useScoutRealtimeDevices.js

@@ -28,12 +28,14 @@ export function useScoutRealtimeDevices(scoutSupabase) {
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
                 if (data.record) {
+                    console.log("[Devices] Device updated:", data.record);
                     dispatch(updateDevice(data.record));
                 }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
                 if (data.old_record) {
+                    console.log("[Devices] Device deleted:", data.old_record);
                     dispatch(deleteDevice(data.old_record));
                 }
                 break;

package/dist/hooks/useScoutRealtimeVersionsSoftware.js

@@ -26,12 +26,14 @@ export function useScoutRealtimeVersionsSoftware(scoutSupabase) {
             case "UPDATE":
                 operation = EnumRealtimeOperation.UPDATE;
                 if (data.record) {
+                    console.log("[VersionsSoftware] Version updated:", data.record);
                     dispatch(upsertVersionSoftware(data.record));
                 }
                 break;
             case "DELETE":
                 operation = EnumRealtimeOperation.DELETE;
                 if (data.old_record) {
+                    console.log("[VersionsSoftware] Version deleted:", data.old_record);
                     dispatch(deleteVersionSoftwareById(data.old_record.id));
                 }
                 break;

package/dist/hooks/useScoutRefresh.js

@@ -4,7 +4,7 @@ import { useStore } from "react-redux";
 import { EnumScoutStateStatus, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiServerProcessingDuration, setHerdModulesApiTotalRequestDuration, setUserApiDuration, setDataProcessingDuration, setCacheLoadDuration, setUser, setDataSource, setDataSourceInfo, setVersionsSoftware, } from "../store/scout";
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
-import { server_get_versions_software } from "../helpers/versions_software";
+import { get_versions_software } from "../helpers/versions_software";
 import { scoutCache } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
 import { createBrowserClient } from "@supabase/ssr";
@@ -110,7 +110,7 @@ export function useScoutRefresh(options = {}) {
                         console.log(`[useScoutRefresh] Updating store with cached herd modules`);
                         dispatch(setHerdModules(cachedHerdModules));
                         dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
-                        // Load cached software versions if available
+                        // Load cached software versions immediately if available
                         if (versionsCacheResult.data && !versionsCacheResult.isStale) {
                             console.log(`[useScoutRefresh] Loaded ${versionsCacheResult.data.length} software versions from cache`);
                             dispatch(setVersionsSoftware(versionsCacheResult.data));
@@ -120,6 +120,7 @@ export function useScoutRefresh(options = {}) {
                             // Background fetch fresh data without blocking
                             (async () => {
                                 try {
+                                    console.log("[useScoutRefresh] Starting background parallel API calls: herd modules, user, software versions");
                                     const backgroundStartTime = Date.now();
                                     const [backgroundHerdModulesResult, backgroundUserResult, backgroundVersionsResult,] = await Promise.all([
                                         (async () => {
@@ -147,46 +148,43 @@ export function useScoutRefresh(options = {}) {
                                         })(),
                                         (async () => {
                                             const start = Date.now();
-                                            const result = await server_get_versions_software();
+                                            const result = await get_versions_software(supabase);
                                             const duration = Date.now() - start;
                                             return { ...result, duration };
                                         })(),
                                     ]);
                                     const backgroundDuration = Date.now() - backgroundStartTime;
+                                    console.log(`[useScoutRefresh] Background parallel API calls completed in ${backgroundDuration}ms (herd modules, user, software versions)`);
                                     // Validate background responses
                                     if (backgroundHerdModulesResult.status === "success" &&
                                         backgroundHerdModulesResult.data &&
                                         Array.isArray(backgroundHerdModulesResult.data) &&
                                         backgroundUserResult &&
                                         backgroundUserResult.data) {
-                                        // Update cache with fresh data
+                                        // Update cache with fresh herd modules data
                                         try {
-                                            await Promise.all([
-                                                scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs),
-                                                backgroundVersionsResult &&
-                                                    backgroundVersionsResult.status === "success" &&
-                                                    backgroundVersionsResult.data
-                                                    ? scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs)
-                                                    : Promise.resolve(),
-                                            ]);
+                                            await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
                                         }
                                         catch (cacheError) {
-                                            console.warn("[useScoutRefresh] Background cache save failed:", cacheError);
+                                            console.warn("[useScoutRefresh] Background herd modules cache save failed:", cacheError);
                                             await handleIndexedDbError(cacheError, "background cache save", async () => {
-                                                const promises = [];
                                                 if (backgroundHerdModulesResult.data) {
-                                                    promises.push(scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs));
-                                                }
-                                                if (backgroundVersionsResult &&
-                                                    backgroundVersionsResult.status === "success" &&
-                                                    backgroundVersionsResult.data) {
-                                                    promises.push(scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs));
-                                                }
-                                                if (promises.length > 0) {
-                                                    await Promise.all(promises);
+                                                    await scoutCache.setHerdModules(backgroundHerdModulesResult.data, cacheTtlMs);
                                                 }
                                             });
                                         }
+                                        // Update cache with fresh software versions separately
+                                        if (backgroundVersionsResult &&
+                                            backgroundVersionsResult.status === "success" &&
+                                            backgroundVersionsResult.data) {
+                                            try {
+                                                await scoutCache.setVersionsSoftware(backgroundVersionsResult.data, cacheTtlMs);
+                                                console.log(`[useScoutRefresh] Background cached ${backgroundVersionsResult.data.length} software versions`);
+                                            }
+                                            catch (versionsCacheError) {
+                                                console.warn("[useScoutRefresh] Background software versions cache save failed:", versionsCacheError);
+                                            }
+                                        }
                                         // Update store with fresh data from background request
                                         console.log(`[useScoutRefresh] Updating store with background herd modules`);
                                         dispatch(setHerdModules(backgroundHerdModulesResult.data));
@@ -232,7 +230,8 @@ export function useScoutRefresh(options = {}) {
                     // Continue with API call
                 }
             }
-            // Step 2: Load fresh data from API
+            // Step 2: Load fresh data from API (herd modules, user, and software versions in parallel)
+            console.log("[useScoutRefresh] Starting parallel API calls: herd modules, user, software versions");
             const parallelStartTime = Date.now();
             const [herdModulesResult, userResult, versionsResult] = await Promise.all([
                 (async () => {
@@ -254,7 +253,7 @@ export function useScoutRefresh(options = {}) {
                 })(),
                 (async () => {
                     const start = Date.now();
-                    const result = await server_get_versions_software();
+                    const result = await get_versions_software(supabase);
                     const duration = Date.now() - start;
                     return {
                         result,
@@ -264,7 +263,7 @@ export function useScoutRefresh(options = {}) {
                 })(),
             ]);
             const parallelDuration = Date.now() - parallelStartTime;
-            console.log(`[useScoutRefresh] Parallel API requests completed in ${parallelDuration}ms`);
+            console.log(`[useScoutRefresh] Parallel API calls completed in ${parallelDuration}ms (herd modules, user, software versions)`);
             // Extract results and timing
             const herdModulesResponse = herdModulesResult.result;
             const res_new_user = userResult.result;
@@ -305,30 +304,26 @@ export function useScoutRefresh(options = {}) {
             // Step 3: Update cache with fresh data
             const cacheSaveStartTime = Date.now();
             try {
-                const cachePromises = [
-                    scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs),
-                ];
-                // Cache software versions if available
+                await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
+                // Cache software versions separately
                 if (versionsResult.result.status === "success" &&
                     versionsResult.result.data) {
-                    cachePromises.push(scoutCache.setVersionsSoftware(versionsResult.result.data, cacheTtlMs));
+                    try {
+                        await scoutCache.setVersionsSoftware(versionsResult.result.data, cacheTtlMs);
+                        console.log(`[useScoutRefresh] Cached ${versionsResult.result.data.length} software versions`);
+                    }
+                    catch (versionsCacheError) {
+                        console.warn("[useScoutRefresh] Failed to cache software versions:", versionsCacheError);
+                    }
                 }
-                await Promise.all(cachePromises);
                 const cacheSaveDuration = Date.now() - cacheSaveStartTime;
                 timingRefs.current.cacheSaveDuration = cacheSaveDuration;
                 console.log(`[useScoutRefresh] Cache updated in ${cacheSaveDuration}ms with TTL: ${Math.round(cacheTtlMs / 1000)}s`);
             }
             catch (cacheError) {
-                console.warn("[useScoutRefresh] Cache save failed:", cacheError);
+                console.warn("[useScoutRefresh] Herd modules cache save failed:", cacheError);
                 await handleIndexedDbError(cacheError, "cache save", async () => {
-                    const retryPromises = [
-                        scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs),
-                    ];
-                    if (versionsResult.result.status === "success" &&
-                        versionsResult.result.data) {
-                        retryPromises.push(scoutCache.setVersionsSoftware(versionsResult.result.data, cacheTtlMs));
-                    }
-                    await Promise.all(retryPromises);
+                    await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
             }
             // Step 4: Conditionally update store with fresh data, skip timestamp-only changes

package/package.json

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