@adventurelabs/scout-core 1.0.64 → 1.0.66

package/dist/helpers/herds.js

@@ -3,7 +3,12 @@ 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,
@@ -65,29 +70,57 @@ 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();
-    // load herds
+    // Measure Supabase client creation
+    const supabaseStartTime = Date.now();
     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: Date.now(),
-            time_sent: Date.now(),
-            server_processing_time_ms: Date.now() - startTime,
+            time_finished: errorTime,
+            time_sent: errorTime,
+            server_processing_time_ms: errorTime - 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);
-    // now serialize the herd modules
+    const herdModuleTime = Date.now() - herdModuleStartTime;
+    console.log(`[server_load_herd_modules] Herd module creation took: ${herdModuleTime}ms`);
+    // Measure serialization
+    const serializationStartTime = Date.now();
     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`);

package/dist/supabase/server.js

@@ -1,8 +1,14 @@
 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();
-    return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
+    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, {
         cookies: {
             getAll() {
                 return cookieStore.getAll();
@@ -19,4 +25,9 @@ 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.64",
+  "version": "1.0.66",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",