@adventurelabs/scout-core 1.0.46 → 1.0.47

package/dist/api_keys/actions.d.ts

@@ -1,4 +1,5 @@
 import { IApiKeyScout } from "../types/db";
+export declare function test_api_key_loading(device_id: string): Promise<boolean>;
 export declare function server_list_api_keys(device_id: string): Promise<IApiKeyScout[]>;
 export declare function server_list_api_keys_batch(device_ids: string[]): Promise<{
     [device_id: number]: IApiKeyScout[];

package/dist/api_keys/actions.js

@@ -1,5 +1,18 @@
 "use server";
 import { newServerClient } from "../supabase/server";
+// Test function to verify individual API key loading works
+export async function test_api_key_loading(device_id) {
+    try {
+        console.log(`[API Key Test] Testing individual API key loading for device ${device_id}`);
+        const api_keys = await server_list_api_keys(device_id);
+        console.log(`[API Key Test] Successfully loaded ${api_keys.length} API keys for device ${device_id}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[API Key Test] Failed to load API keys for device ${device_id}:`, error);
+        return false;
+    }
+}
 export async function server_list_api_keys(device_id) {
     const supabase = await newServerClient();
     const { data, error } = await supabase.rpc("load_api_keys", {
@@ -19,24 +32,38 @@ export async function server_list_api_keys(device_id) {
 }
 export async function server_list_api_keys_batch(device_ids) {
     const startTime = Date.now();
-    console.log(`[API Keys Batch] Starting batch load for ${device_ids.length} devices at ${new Date().toISOString()}`);
-    console.log(`[API Keys Batch] Debug: device_ids array:`, device_ids);
-    console.log(`[API Keys Batch] Debug: device_ids types:`, device_ids.map((id) => ({ id, type: typeof id })));
+    // CRITICAL: Check for UUIDs being passed instead of device IDs
+    const invalidIds = device_ids.filter((id) => !/^\d+$/.test(id));
+    if (invalidIds.length > 0) {
+        console.error(`[CRITICAL] UUIDs detected instead of device IDs:`, invalidIds);
+        console.error(`[CRITICAL] Valid device IDs should be:`, device_ids.filter((id) => /^\d+$/.test(id)));
+        return {};
+    }
     const supabase = await newServerClient();
-    console.log(`[API Keys Batch] Making RPC call to load_api_keys_batch...`);
     const { data, error } = await supabase.rpc("load_api_keys_batch", {
         device_ids: device_ids,
     });
-    const duration = Date.now() - startTime;
     if (error) {
-        console.error(`[API Keys Batch] ERROR after ${duration}ms:`, error.message);
-        return {};
+        console.error(`[API Keys Batch] Database error:`, error.message);
+        console.log(`[API Keys Batch] Falling back to individual calls...`);
+        // Fallback to individual API key loading
+        const result = {};
+        const promises = device_ids.map(async (device_id) => {
+            try {
+                const api_keys = await server_list_api_keys(device_id);
+                result[parseInt(device_id)] = api_keys;
+            }
+            catch (err) {
+                console.warn(`[API Keys Batch] Failed for device ${device_id}:`, err);
+                result[parseInt(device_id)] = [];
+            }
+        });
+        await Promise.all(promises);
+        return result;
     }
     if (!data) {
-        console.log(`[API Keys Batch] No data returned after ${duration}ms`);
         return {};
     }
-    console.log(`[API Keys Batch] RPC completed in ${duration}ms, received ${data.length} API key records`);
     const result = {};
     // Group API keys by device_id
     data.forEach((item) => {
@@ -49,7 +76,5 @@ export async function server_list_api_keys_batch(device_ids) {
             key: item.api_key_key,
         });
     });
-    const totalDuration = Date.now() - startTime;
-    console.log(`[API Keys Batch] COMPLETED in ${totalDuration}ms - returning API keys for ${Object.keys(result).length} devices`);
     return result;
 }

package/dist/helpers/tags.d.ts

@@ -1,5 +1,6 @@
 import { IEventWithTags, ITag } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
+export declare function test_event_loading(device_id: number): Promise<boolean>;
 export declare function server_create_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
 export declare function server_delete_tags_by_ids(tag_ids: number[]): Promise<IWebResponseCompatible<boolean>>;
 export declare function server_update_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;

package/dist/helpers/tags.js

@@ -3,6 +3,25 @@
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { addSignedUrlsToEvents, addSignedUrlToEvent } from "./storage";
+// Test function to verify individual event loading works
+export async function test_event_loading(device_id) {
+    try {
+        console.log(`[Event Test] Testing individual event loading for device ${device_id}`);
+        const events_response = await server_get_events_and_tags_for_device(device_id, 1);
+        if (events_response.status === EnumWebResponse.SUCCESS) {
+            console.log(`[Event Test] Successfully loaded ${events_response.data?.length || 0} events for device ${device_id}`);
+            return true;
+        }
+        else {
+            console.error(`[Event Test] Failed to load events for device ${device_id}:`, events_response.msg);
+            return false;
+        }
+    }
+    catch (error) {
+        console.error(`[Event Test] Failed to load events for device ${device_id}:`, error);
+        return false;
+    }
+}
 export async function server_create_tags(tags) {
     const supabase = await newServerClient();
     // remove id key from tags
@@ -148,30 +167,47 @@ export async function server_get_events_and_tags_for_device(device_id, limit = 3
 }
 export async function server_get_events_and_tags_for_devices_batch(device_ids, limit = 1) {
     const startTime = Date.now();
-    console.log(`[Events Batch] Starting batch load for ${device_ids.length} devices (limit: ${limit}) at ${new Date().toISOString()}`);
-    console.log(`[Events Batch] Debug: device_ids array:`, device_ids);
-    console.log(`[Events Batch] Debug: device_ids types:`, device_ids.map((id) => ({ id, type: typeof id })));
+    // CRITICAL: Check for UUIDs being passed instead of device IDs
+    const invalidIds = device_ids.filter((id) => !/^\d+$/.test(id));
+    if (invalidIds.length > 0) {
+        console.error(`[CRITICAL] UUIDs detected instead of device IDs:`, invalidIds);
+        console.error(`[CRITICAL] Valid device IDs should be:`, device_ids.filter((id) => /^\d+$/.test(id)));
+        return IWebResponse.success({}).to_compatible();
+    }
     const supabase = await newServerClient();
-    console.log(`[Events Batch] Making RPC call to get_events_and_tags_for_devices_batch...`);
     // Use single RPC call for all devices
     const { data, error } = await supabase.rpc("get_events_and_tags_for_devices_batch", {
         device_ids: device_ids,
         limit_per_device: limit,
     });
-    const duration = Date.now() - startTime;
     if (error) {
-        console.error(`[Events Batch] ERROR after ${duration}ms:`, error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: {},
-        };
+        console.error(`[Events Batch] Database error:`, error.message);
+        console.log(`[Events Batch] Falling back to individual calls...`);
+        // Fallback to individual event loading
+        const result = {};
+        const promises = device_ids.map(async (device_id) => {
+            try {
+                const device_id_num = parseInt(device_id);
+                const events_response = await server_get_events_and_tags_for_device(device_id_num, limit);
+                if (events_response.status === EnumWebResponse.SUCCESS &&
+                    events_response.data) {
+                    result[device_id_num] = events_response.data;
+                }
+                else {
+                    result[device_id_num] = [];
+                }
+            }
+            catch (err) {
+                console.warn(`[Events Batch] Failed for device ${device_id}:`, err);
+                result[parseInt(device_id)] = [];
+            }
+        });
+        await Promise.all(promises);
+        return IWebResponse.success(result).to_compatible();
     }
     if (!data) {
-        console.log(`[Events Batch] No data returned after ${duration}ms`);
         return IWebResponse.success({}).to_compatible();
     }
-    console.log(`[Events Batch] RPC completed in ${duration}ms, received ${data.length} event records`);
     // Group events by device_id
     const eventsByDevice = {};
     data.forEach((row) => {
@@ -179,7 +215,7 @@ export async function server_get_events_and_tags_for_devices_batch(device_ids, l
         if (!eventsByDevice[device_id]) {
             eventsByDevice[device_id] = [];
         }
-        // Create event object from the new structure
+        // Create event object from the database function structure
         const event = {
             id: row.event_id,
             inserted_at: row.inserted_at,
@@ -206,8 +242,6 @@ export async function server_get_events_and_tags_for_devices_batch(device_ids, l
         const eventsWithSignedUrls = await addSignedUrlsToEvents(events, supabase);
         result[parseInt(device_id)] = eventsWithSignedUrls;
     }
-    const totalDuration = Date.now() - startTime;
-    console.log(`[Events Batch] COMPLETED in ${totalDuration}ms - returning events for ${Object.keys(result).length} devices`);
     return IWebResponse.success(result).to_compatible();
 }
 export async function get_event_and_tags_by_event_id(event_id) {

package/dist/types/herd_module.js

@@ -52,7 +52,7 @@ export class HerdModule {
             let response_new_devices = await get_devices_by_herd(herd.id, client);
             if (response_new_devices.status == EnumWebResponse.ERROR ||
                 !response_new_devices.data) {
-                console.warn("No devices found for herd");
+                console.warn(`[HerdModule] No devices found for herd ${herd.id}`);
                 return new HerdModule(herd, [], [], Date.now());
             }
             const new_devices = response_new_devices.data;
@@ -61,60 +61,58 @@ export class HerdModule {
             if (new_devices.length > 0) {
                 const batchStartTime = Date.now();
                 try {
-                    console.log(`[HerdModule] Debug: new_devices array:`, new_devices.map((d) => ({
-                        id: d.id,
-                        type: typeof d.id,
-                        created_by: d.created_by,
-                        name: d.name,
-                    })));
                     const device_ids = new_devices.map((device) => (device.id ?? 0).toString());
-                    console.log(`[HerdModule] Starting parallel batch load for ${device_ids.length} devices at ${new Date().toISOString()}:`, device_ids);
+                    // CRITICAL: Check for UUIDs being passed instead of device IDs
+                    const invalidDeviceIds = device_ids.filter((id) => !/^\d+$/.test(id));
+                    if (invalidDeviceIds.length > 0) {
+                        console.error(`[CRITICAL] UUIDs detected in HerdModule:`, invalidDeviceIds);
+                        console.error(`[CRITICAL] Device objects:`, new_devices.map((d) => ({ id: d.id, created_by: d.created_by })));
+                        // Filter out invalid IDs
+                        const validDeviceIds = device_ids.filter((id) => /^\d+$/.test(id));
+                        device_ids.length = 0;
+                        device_ids.push(...validDeviceIds);
+                    }
                     // Load API keys and events in parallel
-                    console.log(`[HerdModule] Initiating Promise.all for API keys and events...`);
                     const [api_keys_batch, events_response] = await Promise.all([
                         server_list_api_keys_batch(device_ids),
                         server_get_events_and_tags_for_devices_batch(device_ids, 1),
                     ]);
-                    const batchDuration = Date.now() - batchStartTime;
-                    console.log(`[HerdModule] Parallel batch load completed in ${batchDuration}ms`);
                     // Assign API keys to devices
                     for (let i = 0; i < new_devices.length; i++) {
                         const device_id = new_devices[i].id ?? 0;
                         new_devices[i].api_keys_scout = api_keys_batch[device_id] || [];
                     }
-                    console.log(`[HerdModule] API keys loaded for ${Object.keys(api_keys_batch).length} devices`);
                     // Process events response
                     if (events_response.status === EnumWebResponse.SUCCESS &&
                         events_response.data) {
                         recent_events_batch = events_response.data;
-                        console.log(`[HerdModule] Events loaded for ${Object.keys(recent_events_batch).length} devices`);
                     }
                 }
                 catch (error) {
-                    console.error(`[HerdModule] CRITICAL ERROR in batch load after ${Date.now() - batchStartTime}ms:`, error);
+                    console.error(`[HerdModule] Batch load error:`, error);
                     // Continue without API keys and events
                 }
             }
             // Run all remaining requests in parallel with individual error handling
             const [res_zones, res_user_roles, total_event_count, res_plans, res_sessions,] = await Promise.allSettled([
                 server_get_more_zones_and_actions_for_herd(herd.id, 0, 10).catch((error) => {
-                    console.warn("Failed to get zones and actions:", error);
+                    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) => {
-                    console.warn("Failed to get user roles:", error);
+                    console.warn(`[HerdModule] Failed to get user roles:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
                 server_get_total_events_by_herd(herd.id, EnumSessionsVisibility.Exclude).catch((error) => {
-                    console.warn("Failed to get total events count:", error);
+                    console.warn(`[HerdModule] Failed to get total events count:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
                 server_get_plans_by_herd(herd.id).catch((error) => {
-                    console.warn("Failed to get plans:", error);
+                    console.warn(`[HerdModule] Failed to get plans:`, error);
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
                 getSessionsByHerdId(client, herd.id).catch((error) => {
-                    console.warn("Failed to get sessions:", error);
+                    console.warn(`[HerdModule] Failed to get sessions:`, error);
                     return [];
                 }),
             ]);
@@ -151,7 +149,7 @@ export class HerdModule {
             return new HerdModule(herd, new_devices, [], Date.now(), user_roles, 0, total_events, total_events, newLabels, plans, zones, sessions);
         }
         catch (error) {
-            console.error("Critical error in HerdModule.from_herd:", error);
+            console.error(`[HerdModule] Critical error in HerdModule.from_herd:`, error);
             // Return a minimal but valid HerdModule instance to prevent complete failure
             return new HerdModule(herd, [], [], Date.now());
         }

package/package.json

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