@adventurelabs/scout-core 1.0.46 → 1.0.48

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,37 +32,70 @@ 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 })));
     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 {};
-    }
-    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) => {
-        const device_id = item.device_id;
-        if (!result[device_id]) {
-            result[device_id] = [];
+    // Check if the batch function exists by trying a simple call
+    try {
+        const { data, error } = await supabase.rpc("load_api_keys_batch", {
+            device_ids: device_ids,
+        });
+        if (error) {
+            // Check if it's a "function does not exist" error
+            if (error.message.includes("function") &&
+                error.message.includes("does not exist")) {
+                console.log(`[API Keys Batch] Batch function not deployed, using individual calls...`);
+            }
+            else {
+                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) {
+            return {};
         }
-        result[device_id].push({
-            id: item.api_key_id.toString(),
-            key: item.api_key_key,
+        const result = {};
+        // Group API keys by device_id
+        data.forEach((item) => {
+            const device_id = item.device_id;
+            if (!result[device_id]) {
+                result[device_id] = [];
+            }
+            result[device_id].push({
+                id: item.api_key_id.toString(),
+                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;
+        return result;
+    }
+    catch (err) {
+        console.error(`[API Keys Batch] Unexpected error:`, err);
+        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;
+    }
 }

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,39 @@ 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 })));
     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 events_response = await server_get_events_and_tags_for_device(parseInt(device_id), limit);
+                if (events_response.status === EnumWebResponse.SUCCESS &&
+                    events_response.data) {
+                    result[parseInt(device_id)] = events_response.data;
+                }
+                else {
+                    result[parseInt(device_id)] = [];
+                }
+            }
+            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 +207,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 +234,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,48 @@ 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);
                     // 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 +139,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.48",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",