@adventurelabs/scout-core 1.0.60 → 1.0.62

package/dist/helpers/herds.d.ts

@@ -1,9 +1,9 @@
 import { IHerd } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IHerdModule } from "../types/herd_module";
+import { IHerdModulesResponseWithStatus } from "../types/herd_module";
 export declare function get_herds(client: SupabaseClient): Promise<IWebResponseCompatible<IHerd[]>>;
 export declare function get_herd_by_slug(slug: string): Promise<IWebResponseCompatible<IHerd>>;
 export declare function deleteHerd(herd_id: number): Promise<IWebResponseCompatible<boolean>>;
 export declare function createHerd(newHerd: any): Promise<IWebResponseCompatible<boolean>>;
-export declare function server_load_herd_modules(): Promise<IHerdModule[]>;
+export declare function server_load_herd_modules(): Promise<IHerdModulesResponseWithStatus>;

package/dist/helpers/herds.js

@@ -1,7 +1,7 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
-import { HerdModule } from "../types/herd_module";
+import { HerdModule, } from "../types/herd_module";
 export async function get_herds(client) {
     const { data: herds } = await client.from("herds").select();
     if (!herds) {
@@ -70,7 +70,13 @@ export async function server_load_herd_modules() {
     const client_supabase = await newServerClient();
     let new_herds = await get_herds(client_supabase);
     if (new_herds.status != EnumWebResponse.SUCCESS || !new_herds.data) {
-        return [];
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "No herds found",
+            data: null,
+            time_finished: Date.now(),
+            server_processing_time_ms: Date.now() - startTime,
+        };
     }
     console.log(`[server_load_herd_modules] Loading ${new_herds.data.length} herds in parallel...`);
     let new_herd_modules = [];
@@ -81,5 +87,11 @@ export async function server_load_herd_modules() {
     const endTime = Date.now();
     const totalLoadTime = endTime - startTime;
     console.log(`[server_load_herd_modules] Loaded ${new_herds.data.length} herds in ${totalLoadTime}ms (parallel processing)`);
-    return serialized_herd_modules;
+    return {
+        status: EnumWebResponse.SUCCESS,
+        msg: "Herd modules loaded successfully",
+        data: serialized_herd_modules,
+        time_finished: endTime,
+        server_processing_time_ms: totalLoadTime,
+    };
 }

package/dist/hooks/useScoutRefresh.js

@@ -4,6 +4,7 @@ import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setHe
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
 import { server_get_user } from "../helpers/users";
+import { EnumWebResponse } from "../types/requests";
 /**
  * Hook for refreshing scout data with detailed timing measurements
  *
@@ -52,26 +53,71 @@ export function useScoutRefresh(options = {}) {
         try {
             dispatch(setStatus(EnumScoutStateStatus.LOADING));
             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.LOADING));
-            // Measure herd modules API call duration
-            const herdModulesStartTime = Date.now();
-            const compatible_new_herd_modules = await server_load_herd_modules();
-            const herdModulesDuration = Date.now() - herdModulesStartTime;
+            // Run API requests in parallel for better performance
+            console.log("[useScoutRefresh] Starting parallel API requests...");
+            const parallelStartTime = Date.now();
+            const [herdModulesResult, userResult] = await Promise.all([
+                (async () => {
+                    const start = Date.now();
+                    const result = await server_load_herd_modules();
+                    const duration = Date.now() - start;
+                    return { result, duration, start };
+                })(),
+                (async () => {
+                    const start = Date.now();
+                    const result = await server_get_user();
+                    const duration = Date.now() - start;
+                    return { result, duration, start };
+                })(),
+            ]);
+            const parallelDuration = Date.now() - parallelStartTime;
+            console.log(`[useScoutRefresh] Parallel API requests completed in ${parallelDuration}ms`);
+            // Extract results and timing
+            const herdModulesResponse = herdModulesResult.result;
+            const res_new_user = userResult.result;
+            const herdModulesDuration = herdModulesResult.duration;
+            const userApiDuration = userResult.duration;
+            // Calculate network latency for herd modules
+            let networkLatencyMs = 0;
+            if (herdModulesResponse.status === EnumWebResponse.SUCCESS &&
+                herdModulesResponse.data) {
+                const serverFinishTime = herdModulesResponse.time_finished;
+                const clientReceiveTime = Date.now();
+                const estimatedNetworkLatency = clientReceiveTime - serverFinishTime;
+                networkLatencyMs = Math.max(0, estimatedNetworkLatency);
+                console.log(`[useScoutRefresh] Network latency calculation:`);
+                console.log(`  - Server finished at: ${new Date(serverFinishTime).toISOString()}`);
+                console.log(`  - Client received at: ${new Date(clientReceiveTime).toISOString()}`);
+                console.log(`  - Estimated network latency: ${networkLatencyMs}ms`);
+                console.log(`  - Server processing time: ${herdModulesResponse.server_processing_time_ms}ms`);
+            }
+            // Store timing values
             timingRefs.current.herdModulesDuration = herdModulesDuration;
-            dispatch(setHerdModulesApiDuration(herdModulesDuration));
-            // Measure user API call duration
-            const userApiStartTime = Date.now();
-            const res_new_user = await server_get_user();
-            const userApiDuration = Date.now() - userApiStartTime;
             timingRefs.current.userApiDuration = userApiDuration;
+            // Dispatch timing actions
+            dispatch(setHerdModulesApiDuration(herdModulesDuration));
             dispatch(setUserApiDuration(userApiDuration));
+            // Calculate network overhead
+            const totalApiTime = herdModulesDuration + userApiDuration;
+            const networkOverhead = parallelDuration - Math.max(herdModulesDuration, userApiDuration);
+            console.log(`[useScoutRefresh] API timing breakdown:`);
+            console.log(`  - Herd modules: ${herdModulesDuration}ms (server processing + network)`);
+            console.log(`  - User API: ${userApiDuration}ms (server processing + network)`);
+            console.log(`  - Parallel execution: ${parallelDuration}ms`);
+            console.log(`  - Network overhead: ${networkOverhead}ms`);
+            if (networkLatencyMs > 0) {
+                console.log(`  - Estimated network latency: ${networkLatencyMs}ms`);
+            }
             // Validate API responses
-            if (!compatible_new_herd_modules ||
-                !Array.isArray(compatible_new_herd_modules)) {
+            if (!herdModulesResponse.data ||
+                !Array.isArray(herdModulesResponse.data)) {
                 throw new Error("Invalid herd modules response");
             }
             if (!res_new_user || !res_new_user.data) {
                 throw new Error("Invalid user response");
             }
+            // Use the validated data
+            const compatible_new_herd_modules = herdModulesResponse.data;
             // Measure data processing duration
             const dataProcessingStartTime = Date.now();
             dispatch(setHerdModules(compatible_new_herd_modules));
@@ -113,13 +159,16 @@ export function useScoutRefresh(options = {}) {
             const loadingDuration = Date.now() - startTime;
             dispatch(setHerdModulesLoadedInMs(loadingDuration));
             dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
-            // Log timing statistics
-            console.log("[useScoutRefresh] Refresh completed successfully. Timing breakdown:");
+            // Log comprehensive timing statistics
+            console.log("[useScoutRefresh] Refresh completed successfully. Full timing breakdown:");
             console.log(`  - Herd modules API: ${herdModulesDuration}ms`);
             console.log(`  - User API: ${userApiDuration}ms`);
+            console.log(`  - Parallel execution: ${parallelDuration}ms`);
+            console.log(`  - Network overhead: ${networkOverhead}ms`);
             console.log(`  - Data processing: ${dataProcessingDuration}ms`);
             console.log(`  - LocalStorage operations: ${localStorageDuration}ms`);
             console.log(`  - Total duration: ${loadingDuration}ms`);
+            console.log(`  - Time saved with parallel execution: ${totalApiTime - parallelDuration}ms`);
             onRefreshComplete?.();
         }
         catch (error) {

package/dist/types/herd_module.d.ts

@@ -1,5 +1,6 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+import { EnumWebResponse } from "./requests";
 export declare enum EnumHerdModulesLoadingState {
     NOT_LOADING = "NOT_LOADING",
     LOADING = "LOADING",
@@ -39,3 +40,15 @@ export interface IHerdModule {
     sessions: ISessionWithCoordinates[];
     layers: ILayer[];
 }
+export interface IHerdModulesResponse {
+    data: IHerdModule[];
+    time_finished: number;
+    server_processing_time_ms: number;
+}
+export interface IHerdModulesResponseWithStatus {
+    status: EnumWebResponse;
+    msg: string;
+    data: IHerdModule[] | null;
+    time_finished: number;
+    server_processing_time_ms: number;
+}

package/package.json

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