@adventurelabs/scout-core 1.0.41 → 1.0.43

package/dist/api_keys/actions.d.ts

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

package/dist/api_keys/actions.js

@@ -18,18 +18,23 @@ export async function server_list_api_keys(device_id) {
     return data_to_return;
 }
 export async function server_list_api_keys_batch(device_ids) {
-    console.log(`[API Keys Batch] Starting batch load for ${device_ids.length} devices`);
+    const startTime = Date.now();
+    console.log(`[API Keys Batch] Starting batch load for ${device_ids.length} devices at ${new Date().toISOString()}`);
     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("Error listing API keys in batch:", error.message);
+        console.error(`[API Keys Batch] ERROR after ${duration}ms:`, error.message);
         return {};
     }
-    if (!data)
+    if (!data) {
+        console.log(`[API Keys Batch] No data returned after ${duration}ms`);
         return {};
-    console.log(`[API Keys Batch] Received ${data.length} API key records`);
+    }
+    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) => {
@@ -42,6 +47,7 @@ export async function server_list_api_keys_batch(device_ids) {
             key: item.api_key_key,
         });
     });
-    console.log(`[API Keys Batch] Returning API keys for ${Object.keys(result).length} devices`);
+    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

@@ -5,7 +5,7 @@ export declare function server_delete_tags_by_ids(tag_ids: number[]): Promise<IW
 export declare function server_update_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
 export declare function server_get_more_events_with_tags_by_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IEventWithTags[]>>;
 export declare function server_get_events_and_tags_for_device(device_id: number, limit?: number): Promise<IWebResponseCompatible<IEventWithTags[]>>;
-export declare function server_get_events_and_tags_for_devices_batch(device_ids: number[], limit?: number): Promise<IWebResponseCompatible<{
+export declare function server_get_events_and_tags_for_devices_batch(device_ids: string[], limit?: number): Promise<IWebResponseCompatible<{
     [device_id: number]: IEventWithTags[];
 }>>;
 export declare function get_event_and_tags_by_event_id(event_id: number): Promise<IWebResponseCompatible<IEventWithTags>>;

package/dist/helpers/tags.js

@@ -147,24 +147,29 @@ export async function server_get_events_and_tags_for_device(device_id, limit = 3
     return IWebResponse.success(eventsWithSignedUrls).to_compatible();
 }
 export async function server_get_events_and_tags_for_devices_batch(device_ids, limit = 1) {
-    console.log(`[Events Batch] Starting batch load for ${device_ids.length} devices (limit: ${limit})`);
+    const startTime = Date.now();
+    console.log(`[Events Batch] Starting batch load for ${device_ids.length} devices (limit: ${limit}) at ${new Date().toISOString()}`);
     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("Error fetching events for devices in batch:", error.message);
+        console.error(`[Events Batch] ERROR after ${duration}ms:`, error.message);
         return {
             status: EnumWebResponse.ERROR,
             msg: error.message,
             data: {},
         };
     }
-    if (!data)
+    if (!data) {
+        console.log(`[Events Batch] No data returned after ${duration}ms`);
         return IWebResponse.success({}).to_compatible();
-    console.log(`[Events Batch] Received ${data.length} event records`);
+    }
+    console.log(`[Events Batch] RPC completed in ${duration}ms, received ${data.length} event records`);
     // Group events by device_id
     const eventsByDevice = {};
     data.forEach((row) => {
@@ -199,7 +204,8 @@ 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;
     }
-    console.log(`[Events Batch] Returning events for ${Object.keys(result).length} devices`);
+    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/providers/ScoutRefreshProvider.d.ts

@@ -746,7 +746,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
         };
         load_api_keys_batch: {
             Args: {
-                device_ids: number[];
+                device_ids: string[];
             };
             Returns: {
                 device_id: number;
@@ -756,7 +756,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", {
         };
         get_events_and_tags_for_devices_batch: {
             Args: {
-                device_ids: number[];
+                device_ids: string[];
                 limit_per_device: number;
             };
             Returns: {

package/dist/supabase/server.d.ts

@@ -737,7 +737,7 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
         };
         load_api_keys_batch: {
             Args: {
-                device_ids: number[];
+                device_ids: string[];
             };
             Returns: {
                 device_id: number;
@@ -747,7 +747,7 @@ export declare function newServerClient(): Promise<import("@supabase/supabase-js
         };
         get_events_and_tags_for_devices_batch: {
             Args: {
-                device_ids: number[];
+                device_ids: string[];
                 limit_per_device: number;
             };
             Returns: {

package/dist/types/herd_module.js

@@ -59,14 +59,18 @@ export class HerdModule {
             // get api keys and events for all devices in batch
             let recent_events_batch = {};
             if (new_devices.length > 0) {
+                const batchStartTime = Date.now();
                 try {
-                    const device_ids = new_devices.map((device) => device.id ?? 0);
-                    console.log(`[HerdModule] Loading batch data for ${device_ids.length} devices:`, device_ids);
+                    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;
@@ -81,7 +85,7 @@ export class HerdModule {
                     }
                 }
                 catch (error) {
-                    console.warn("Failed to load API keys or events for devices:", error);
+                    console.error(`[HerdModule] CRITICAL ERROR in batch load after ${Date.now() - batchStartTime}ms:`, error);
                     // Continue without API keys and events
                 }
             }

package/dist/types/supabase.d.ts

@@ -804,7 +804,7 @@ export type Database = {
             };
             load_api_keys_batch: {
                 Args: {
-                    device_ids: number[];
+                    device_ids: string[];
                 };
                 Returns: {
                     device_id: number;
@@ -814,7 +814,7 @@ export type Database = {
             };
             get_events_and_tags_for_devices_batch: {
                 Args: {
-                    device_ids: number[];
+                    device_ids: string[];
                     limit_per_device: number;
                 };
                 Returns: {

package/package.json

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