@adventurelabs/scout-core 1.0.65 → 1.0.67

package/dist/helpers/herds.js

@@ -3,12 +3,7 @@ import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { HerdModule, } from "../types/herd_module";
 export async function get_herds(client) {
-    const queryStartTime = Date.now();
-    console.log(`[get_herds] Starting database query at ${new Date(queryStartTime).toISOString()}`);
     const { data: herds } = await client.from("herds").select();
-    const queryEndTime = Date.now();
-    const queryDuration = queryEndTime - queryStartTime;
-    console.log(`[get_herds] Database query completed in ${queryDuration}ms`);
     if (!herds) {
         return {
             status: EnumWebResponse.ERROR,
@@ -70,57 +65,28 @@ export async function createHerd(newHerd) {
     }
 }
 export async function server_load_herd_modules() {
-    const requestReceivedTime = Date.now();
-    console.log(`[server_load_herd_modules] Request received at: ${new Date(requestReceivedTime).toISOString()}`);
     const startTime = Date.now();
-    // Measure Supabase client creation
-    const supabaseStartTime = Date.now();
+    // load herds
     const client_supabase = await newServerClient();
-    const supabaseTime = Date.now() - supabaseStartTime;
-    console.log(`[server_load_herd_modules] Supabase client creation took: ${supabaseTime}ms`);
-    // Measure database connection and initial query
-    const dbStartTime = Date.now();
     let new_herds = await get_herds(client_supabase);
-    const dbConnectionTime = Date.now() - dbStartTime;
-    console.log(`[server_load_herd_modules] Database connection and initial herds query took: ${dbConnectionTime}ms`);
     if (new_herds.status != EnumWebResponse.SUCCESS || !new_herds.data) {
-        const errorTime = Date.now();
         return {
             status: EnumWebResponse.ERROR,
             msg: "No herds found",
             data: null,
-            time_finished: errorTime,
-            time_sent: errorTime,
-            server_processing_time_ms: errorTime - startTime,
+            time_finished: Date.now(),
+            time_sent: Date.now(),
+            server_processing_time_ms: Date.now() - startTime,
         };
     }
-    console.log(`[server_load_herd_modules] Loading ${new_herds.data.length} herds in parallel...`);
-    // Measure herd module creation
-    const herdModuleStartTime = Date.now();
     let new_herd_modules = [];
     const herdModulePromises = new_herds.data.map((herd) => HerdModule.from_herd(herd, client_supabase));
     new_herd_modules = await Promise.all(herdModulePromises);
-    const herdModuleTime = Date.now() - herdModuleStartTime;
-    console.log(`[server_load_herd_modules] Herd module creation took: ${herdModuleTime}ms`);
-    // Measure serialization
-    const serializationStartTime = Date.now();
+    // now serialize the herd modules
     let serialized_herd_modules = new_herd_modules.map((herd_module) => herd_module.to_serializable());
-    const serializationTime = Date.now() - serializationStartTime;
-    console.log(`[server_load_herd_modules] Serialization took: ${serializationTime}ms`);
     const endTime = Date.now();
     const totalLoadTime = endTime - startTime;
-    // Calculate detailed timing breakdown
-    const timeToClient = endTime - requestReceivedTime;
-    const processingTime = endTime - startTime;
     console.log(`[server_load_herd_modules] Loaded ${new_herds.data.length} herds in ${totalLoadTime}ms (parallel processing)`);
-    console.log(`[server_load_herd_modules] Detailed timing breakdown:`);
-    console.log(`  - Request received to start: ${startTime - requestReceivedTime}ms`);
-    console.log(`  - Supabase client creation: ${supabaseTime}ms`);
-    console.log(`  - Database connection & query: ${dbConnectionTime}ms`);
-    console.log(`  - Herd module creation: ${herdModuleTime}ms`);
-    console.log(`  - Serialization: ${serializationTime}ms`);
-    console.log(`  - Total processing time: ${processingTime}ms`);
-    console.log(`  - Total time to client: ${timeToClient}ms`);
     // Record the time when we're about to send the response
     const timeSent = Date.now();
     return {

package/dist/helpers/users.d.ts

@@ -1,6 +1,7 @@
 import { IUser, IUserAndRole, IUserRolePerHerd, Role } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
 export declare function server_get_user_roles(herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd[]>>;
 export declare function server_get_user(): Promise<IWebResponseCompatible<IUser | null>>;
-export declare function server_get_users_with_herd_access(herd_id: number): Promise<IWebResponseCompatible<IUserAndRole[] | null>>;
+export declare function server_get_users_with_herd_access(herd_id: number, supabaseClient?: SupabaseClient): Promise<IWebResponseCompatible<IUserAndRole[]>>;
 export declare function server_upsert_user_with_role(herd_id: number, username: string, role: Role): Promise<IWebResponseCompatible<IUserAndRole | null>>;

package/dist/helpers/users.js

@@ -25,16 +25,33 @@ export async function server_get_user() {
     const new_user = data.user;
     return IWebResponse.success(new_user).to_compatible();
 }
-export async function server_get_users_with_herd_access(herd_id) {
-    const supabase = await newServerClient();
+export async function server_get_users_with_herd_access(herd_id, supabaseClient) {
+    const supabase = supabaseClient || (await newServerClient());
     const { data, error } = await supabase
         .from("users_roles_per_herd")
-        .select("user:users(*), role")
+        .select(`
+      role,
+      users (
+        id,
+        username
+      )
+    `)
         .eq("herd_id", herd_id);
     if (error) {
-        return IWebResponse.error(error.message).to_compatible();
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        // Transform the data to match IUserAndRole interface
+        const transformedData = data.map((item) => ({
+            user: item.users,
+            role: item.role,
+        }));
+        return IWebResponse.success(transformedData).to_compatible();
     }
-    return IWebResponse.success(data).to_compatible();
 }
 export async function server_upsert_user_with_role(herd_id, username, role) {
     const supabase = await newServerClient();

package/dist/hooks/useScoutRefresh.js

@@ -60,6 +60,7 @@ export function useScoutRefresh(options = {}) {
                 (async () => {
                     const start = Date.now();
                     console.log(`[useScoutRefresh] Starting herd modules request at ${new Date(start).toISOString()}`);
+                    // High priority request with optimization
                     const result = await server_load_herd_modules();
                     const duration = Date.now() - start;
                     console.log(`[useScoutRefresh] Herd modules request completed in ${duration}ms`);
@@ -68,6 +69,7 @@ export function useScoutRefresh(options = {}) {
                 (async () => {
                     const start = Date.now();
                     console.log(`[useScoutRefresh] Starting user request at ${new Date(start).toISOString()}`);
+                    // High priority request with optimization
                     const result = await server_get_user();
                     const duration = Date.now() - start;
                     console.log(`[useScoutRefresh] User request completed in ${duration}ms`);
@@ -96,37 +98,13 @@ export function useScoutRefresh(options = {}) {
             if (herdModulesResponse.status === EnumWebResponse.SUCCESS &&
                 herdModulesResponse.data) {
                 const serverFinishTime = herdModulesResponse.time_finished;
-                const serverSentTime = herdModulesResponse.time_sent;
                 const clientReceiveTime = Date.now();
-                // More accurate network latency: from when server sent to when client received
-                const estimatedNetworkLatency = clientReceiveTime - serverSentTime;
+                const estimatedNetworkLatency = clientReceiveTime - serverFinishTime;
                 networkLatencyMs = Math.max(0, estimatedNetworkLatency);
-                // Time between server finishing processing and sending response
-                const serverOverhead = serverSentTime - serverFinishTime;
-                console.log(`[useScoutRefresh] Network latency calculation:`);
-                console.log(`  - Server finished processing at: ${new Date(serverFinishTime).toISOString()}`);
-                console.log(`  - Server sent response at: ${new Date(serverSentTime).toISOString()}`);
-                console.log(`  - Client received at: ${new Date(clientReceiveTime).toISOString()}`);
-                console.log(`  - Server processing time: ${herdModulesResponse.server_processing_time_ms}ms`);
-                console.log(`  - Server overhead (finish to send): ${serverOverhead}ms`);
-                console.log(`  - Estimated network latency: ${networkLatencyMs}ms`);
-                console.log(`  - Client total time: ${herdModulesDuration}ms`);
-                console.log(`  - Breakdown: ${herdModulesResponse.server_processing_time_ms}ms (server) + ${serverOverhead}ms (overhead) + ${networkLatencyMs}ms (network) = ${herdModulesResponse.server_processing_time_ms +
-                    serverOverhead +
-                    networkLatencyMs}ms`);
-                // Additional analysis
-                if (herdModulesResponse.data.length > 0) {
-                    const totalDevices = herdModulesResponse.data.reduce((sum, hm) => sum + (hm.devices?.length || 0), 0);
-                    const totalEvents = herdModulesResponse.data.reduce((sum, hm) => sum + (hm.events?.length || 0), 0);
-                    console.log(`  - Response size analysis:`);
-                    console.log(`    * Herds: ${herdModulesResponse.data.length}`);
-                    console.log(`    * Total devices: ${totalDevices}`);
-                    console.log(`    * Total events: ${totalEvents}`);
-                    console.log(`    * Estimated payload: ~${Math.round((herdModulesResponse.data.length * 2 +
-                        totalDevices * 3 +
-                        totalEvents * 5) /
-                        1024)}KB`);
-                }
+                console.log(`[useScoutRefresh] Herd modules performance:`);
+                console.log(`  - Server processing: ${herdModulesResponse.server_processing_time_ms}ms`);
+                console.log(`  - Network latency: ${networkLatencyMs}ms`);
+                console.log(`  - Total client time: ${herdModulesDuration}ms`);
             }
             // Store timing values
             timingRefs.current.herdModulesDuration = herdModulesDuration;
@@ -137,14 +115,11 @@ export function useScoutRefresh(options = {}) {
             // 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(`[useScoutRefresh] API performance:`);
+            console.log(`  - Herd modules: ${herdModulesDuration}ms`);
+            console.log(`  - User API: ${userApiDuration}ms`);
             console.log(`  - Parallel execution: ${parallelDuration}ms`);
-            console.log(`  - Network overhead: ${networkOverhead}ms`);
-            if (networkLatencyMs > 0) {
-                console.log(`  - Estimated network latency: ${networkLatencyMs}ms`);
-            }
+            console.log(`  - Time saved with parallel: ${totalApiTime - parallelDuration}ms`);
             // Validate API responses
             const validationStartTime = Date.now();
             if (!herdModulesResponse.data ||
@@ -199,16 +174,13 @@ export function useScoutRefresh(options = {}) {
             const loadingDuration = Date.now() - startTime;
             dispatch(setHerdModulesLoadedInMs(loadingDuration));
             dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
-            // Log comprehensive timing statistics
-            console.log("[useScoutRefresh] Refresh completed successfully. Full timing breakdown:");
-            console.log(`  - Herd modules API: ${herdModulesDuration}ms`);
+            // Log essential performance metrics
+            console.log(`[useScoutRefresh] Refresh completed successfully:`);
+            console.log(`  - Total duration: ${loadingDuration}ms`);
+            console.log(`  - Herd modules: ${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`);
+            console.log(`  - Time saved with parallel: ${totalApiTime - parallelDuration}ms`);
             onRefreshComplete?.();
         }
         catch (error) {
@@ -218,13 +190,11 @@ export function useScoutRefresh(options = {}) {
             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.UNSUCCESSFULLY_LOADED));
             dispatch(setHerdModulesLoadedInMs(loadingDuration));
             dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
-            // Log timing statistics even on error
-            console.log("[useScoutRefresh] Refresh failed. Partial timing breakdown:");
-            console.log(`  - Herd modules API: ${timingRefs.current.herdModulesDuration}ms`);
-            console.log(`  - User API: ${timingRefs.current.userApiDuration}ms`);
-            console.log(`  - Data processing: ${timingRefs.current.dataProcessingDuration}ms`);
-            console.log(`  - LocalStorage operations: ${timingRefs.current.localStorageDuration}ms`);
+            // Log essential error metrics
+            console.log(`[useScoutRefresh] Refresh failed:`);
             console.log(`  - Total duration: ${loadingDuration}ms`);
+            console.log(`  - Herd modules: ${timingRefs.current.herdModulesDuration}ms`);
+            console.log(`  - User API: ${timingRefs.current.userApiDuration}ms`);
         }
         finally {
             refreshInProgressRef.current = false;

package/dist/supabase/server.js

@@ -1,14 +1,8 @@
 import { createServerClient } from "@supabase/ssr";
 import { cookies } from "next/headers";
 export async function newServerClient() {
-    const startTime = Date.now();
-    console.log(`[newServerClient] Starting client creation at ${new Date(startTime).toISOString()}`);
-    const cookieStartTime = Date.now();
     const cookieStore = await cookies();
-    const cookieTime = Date.now() - cookieStartTime;
-    console.log(`[newServerClient] Cookie retrieval took: ${cookieTime}ms`);
-    const supabaseStartTime = Date.now();
-    const client = createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
+    return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
         cookies: {
             getAll() {
                 return cookieStore.getAll();
@@ -25,9 +19,4 @@ export async function newServerClient() {
             },
         },
     });
-    const supabaseTime = Date.now() - supabaseStartTime;
-    console.log(`[newServerClient] Supabase client creation took: ${supabaseTime}ms`);
-    const totalTime = Date.now() - startTime;
-    console.log(`[newServerClient] Total client creation time: ${totalTime}ms`);
-    return client;
 }

package/dist/types/herd_module.js

@@ -100,7 +100,7 @@ export class HerdModule {
                     console.warn(`[HerdModule] Failed to get zones and actions:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
-                server_get_users_with_herd_access(herd.id).catch((error) => {
+                server_get_users_with_herd_access(herd.id, client).catch((error) => {
                     console.warn(`[HerdModule] Failed to get user roles:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),

package/package.json

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